CISC 220

Question 1

Why is it unwise to use gets() for production code?

Answer 1

Because there is no specified limit to the amount of characters read, it is insecure.

Gets stops reading after reading a NULL terminator or EOF.
You can write into memory that you shouldn’t be able to.

Question 2

What is morris worm?

Answer 2

Since gets doesn’t half a bound on its input, it is possible to overflow the buffer without an error message.

The worm is able to take control to replicate itself on a host computer.

Question 3

getc or fgetc

Answer 3

Read standard input one character at a time.

Question 4

fgets(buffer name, buffer length, stdin);

Answer 4

Reads standard input, passing stdin for the stream pointer

Question 5

fscanf(FILE *stream, const char *format, &variables to store results …)

Answer 5

Reads formatted input, but mixes the I/O and parse error handling.

Returns number of things successfully converted.

Question 6

Rewind(FILE *f)

Answer 6

Rewinds the file to set a pointer to the beginning of the file.

Question 7

fputc(int ch, FILE *stream);

Answer 7

Writes a character to an output stream.

Returns the written character on success, or EOF on failure.

Question 8

fputs(const char *str, FILE *stream);

Answer 8

Writes a null-terminated string to an output stream.
- the terminating null character is not written.
- returns a non-negative value on success or EOF on failure.

Question 9

fprintf(FILE *stream, const char *format, whatever you want written…)

Answer 9

Works similarly to printf except it writes to the specified stream instead of standard out.

Question 10

long ftell(FILE *stream);

Answer 10

Returns the file position for a stream.

Question 11

int fseek(FILE *stream, long offset, int origin);

Answer 11

Sets the file position for a stream.

If the stream is open in binary mode/UNIX, the new position is exactly offset bites, measured from the beginning of the file (ie. array index) if origin is SEEK_SET, from the current file position if origin is SEEK_CUR, and from the end of the file, if origin is SEEK_END.

Question 12

FILE *f = fopen(filename, “r+”);

Answer 12

Allows you to read and write to a file with the +.

To do this, you have to call fseek() or rewind() if you want to read after writing to a file. If you want to write after reading, you have to call fseek() or rewind().

Question 13

char *s = strtok(char *str, “token”);
char *s = strtok(NULL, “”);

Answer 13

Parses a string by a token.

Searches for the first character not equal to the token character, then find the first token and replaces that token with a null-terminator and returns a pointer to the beginning of the substring.

• tokenizing with strtok fails when there is an empty field.

Line-oriented data can be read from a file using fgets and then processed using strtok or scanf.

Question 14

n = sscanf(string, “format”, new_string);

Answer 14

Uses a format string to control the tokenization of a string.

• Returns the number of successful conversions.
• most conversions eat up all the whitespace and discards the leading white space characters, and ends when a trailing white space character is found (or at end of string). %c and %[] can be used to convert whitespace.
• the maximum field whist can be specified after the %.
• %s and %[] always store the null-terminator as well as the matched characters.
• can use the following format to match spaces: “\”%[^\”]\””.

Question 15

Two pointers are equal if:

Answer 15

• they both point to the same object
• they both point one past the end of the same array
• they both have the value NULL

Question 16

What is the too-far-pointer

Answer 16

A pointer which points to the element one position past the end of the array.

Question 17

scanf(“formatting string”, &ptr-variable);

Answer 17

Reads data from standard input and tries to convert the data into the format, specified by the formatting string.

Returns the number of successfully converted arguments, or EOF, if input failure occurs.

Question 18

Lifetimes

Answer 18

Automatic Storage: lifetime of the block that they are defined in. Lifetime begins when function is entered, and ends when function returns.

Static storage duration: the duration of objects declared at file scope. The lifetime is the entire execution of the program, and the value stored in the object is initialized only once, prior to the main function.

Allocated storage duration: the lifetime of an allocated object begins with the allocated function, returns and ends when the deallocation function is called.

Regular arrays -automatic storage
Variable length arrays - automatic storage
Dynamically allocated memory - allocated storage duration

Question 19

Dynamically allocated memory

Answer 19

Data structures, such as stacks, cues, lists, sets, and maps are usually implemented so that they can grow and shrink as elements are added, and removed.

Question 20

Why is deallocation important?

Answer 20

If you do not deallocate newly allocated memory, the program will continue to consume more and more memory until there is no more memory left to be consumed.

Question 21

When to use allocated memory?

Answer 21

• used when the exact memory requirements are not known before runtime.
• less efficient than statically allocated memory because the memory manager needs to allocate memory from the heap.
• Memory leaks occur when the requester neglects to return unused memory back to the memory manager.

Question 22

int *arr = malloc(size_t n * sizeof(int));

Answer 22

Attempts to allocate an uninitialized block of memory of a specified size (sizes are measured in terms of the size of char in C).

Returns a pointer to the allocated memory, or the NULL pointer if the request could not be fulfilled.

Question 23

How are sizes measured in C?

Answer 23

Sizes in C are measured in terms of the size of char.

Question 24

int *arr = calloc(size_t n, sizeof(int));

Answer 24

Attempts to allocate a block of memory for n objects, each having a specified size, then initializes all bites in the allocated memory to 0.

Returns a pointer to the allocated memory or NULL if request fails.

Question 25

Why can’t you use sizeof() to find out the size of an array in a function?

Answer 25

The compiler treats an array as a pointer, so when you use sizeof() it returns the size of a pointer, not the array.

You can either pass in the integer value of number of objects within the array. Or you can use INT_MIN when iterating over values in an array to indicate the end of an array.

Ex.

void g(int n, int d[n]);
void h(int a[]) {
int i = 0;
while (a[i] != INT_MIN) {
}
}

Question 26

void *realloc(void *ptr, size_t new_size);

Answer 26

Attempts to re-allocate a block of memory that was previously allocated by malloc, calloc, or realloc.

Returns a pointer to the newly allocated memory.

Any excess memory is not initialized.

Question 27

typedef type alias

Answer 27

This declaration provides away to declare an identifier as a type alias.
- Used to replace a complex type name.

Question 28

struct name {
double x;
double y;
};

Answer 28

A structure is a group of variables in one block of memory, having a single name.

• zero initialized.
• point2 p = {2.0, 3.0}
• to dereference pointer to a structure, use —>.
• point2 *p = malloc(sizeof(point2));
  ptr->x = 200.00

To access:

struct point2 p;
printf(“%f, %f\n”, p.x, p.y);

Question 29

What is a const type?

Answer 29

Objects declared with const-qualified types, maybe placed in read-only memory by the compiler, and if the address of a const object is never taken in a program, it may not be stored at all.
- you cannot change the variable again.

Question 30

What is an include guard?

Answer 30

ifndef HEADER_H

It prevents the header file from being included more than once in a compilation unit.

• Traditionally implemented through preprocessor directives.

#define HEADER_H

Question 31

assert(condition);

Answer 31

Allows the programmer to cause a running program to terminate if the condition is false.

Question 32

int n = sprintf(buffer, “(%g, %g)”, p.x, p.y);

Answer 32

Is a formatted print which prints to a string.

Returns the number of characters written to the buffer NOT COUNTING THE NULL-TERMINATOR.

You must allocate a buffer large enough for a returned string.
- char *buf = malloc(15 * 2 +5 * sizeof(char));

Question 33

void *memcpy(void *dest, const void *source, size_t count);

Answer 33

Copies count characters from the object, pointed to by source to the object pointed to by dest.

• Both objects are interpreted as arrays of unsigned char.
• Returns a copy of dest.

Question 34

void *memmove(&dest, &source, size_t count);

Answer 34

Copies count characters from the object pointed to by source to the object pointed to by dest.

• objects may overlap (you can have dest and source be the same array)
• copying takes place as if the characters were copied to a temporary character array, and then copied from the array to dest.
• returns a copy of dest.

Question 35

int n = snprintf(char *buf, size_t bufsz, const char *format, …arguments to print into buffer);

Answer 35

Write the results to a character string buffer.

• at most bufsz -1 characters are written.
• more safe as you can restrict number of characters to be written.
• Returns the number of characters which would have been written to the buffer, if bufsz was ignored.

Question 36

include <stdio.h></stdio.h>

Answer 36

A preprocessor directive which processes and inserts contents of a file into the C source code file before the compiler transforms the code into machine code.

Contains function declarations for puts and printf.

Question 37

File scope

Answer 37

Identifier is accessible everywhere in the file it is declared after the point where it is declared.

If an identifier is declared outside of a function or parameter list, the identifier has file scope.

Question 38

Block scope

Answer 38

If an identifier is declared inside a block or in a parameter list, the identifier has block scope.

The identifier is accessible everywhere in the block after the point where it is declared.

Question 39

Nested scopes

Answer 39

Identifiers with the same name can be declared in different scopes.

An identifier declared at an inner scope takes precedence over an identifier declared at an outer scope.

Question 40

Function prototype scope

Answer 40

A function prototype is a declaration of a function, similar to a Java abstract method.

A parameter in a function prototype has function, prototype scope.

• Does not include the function body
• A C file that calls a function can be compiled as long as the function prototype is given.

Question 41

Phony targets

make target

Answer 41

When using make, a phoney target is one that is not the name of a file rather it is just a name for a recipe to be executed when you make an explicit request.

• to build a phoney target, you tell make to specifically build that target.

Question 42

What does the C preprocessor do when it encounters an #include directive in a C source code file?

Answer 42

The preprocessor processes and inserts content from the specified header file before the compiler transforms the source code into machine code.

Question 43

How does a C program set an exit status?

Answer 43

They set their exit statuses through it’s return function, where 0 indicates a successful run and any positive integer indicates an error occurred.

Question 44

What is the main difference between an int in Java and an int in C?

Answer 44

The main difference is that the size/number of bytes for an int in Java is known and constant, while an int in C has no exact specified size.

Question 45

What character is used to indicate the end of a string?

Answer 45

\0

Question 46

Disadvantages to void pointers

Answer 46

• has to use dynamically allocated storage, and therefore is slower and can increase the risk of memory leaks.
• Has no static type safety.

Question 47

What are string literals?

Answer 47

A string literal is a sequence of characters enclosed by double quotes.