Memory Allocation Questions and Answers

Answer: B

Correct answer: No

A statically allocated array has its size fixed when the program is compiled, and there is no mechanism to change it at run time.

Obtaining a larger one means allocating fresh storage dynamically and copying the contents across - which is exactly what realloc does for heap blocks. This inflexibility is the principal reason dynamic allocation exists, and it is why every growable structure in C is built on the heap.

Answer: A

Correct answer: points to memory that has already been freed

Calling free() releases the block but leaves the pointer holding its old address, and using it afterwards is undefined behaviour. Setting the pointer to NULL immediately after freeing it is the standard guard against this.

Answer: C

Correct answer: 10.100000

The value is written to the union's float member and read back through the same member, so nothing is reinterpreted and the value is intact.

It prints as 10.100000 because %f defaults to six decimal places. Remember that a union holds only one member at a time, all sharing the same storage: writing t->f destroys whatever t->i or t->c contained, and reading a different member afterwards would reinterpret the float's bits.

Answer: C

Correct answer: 24 bytes

p is a pointer to an array of MAXCOL integers, so *p is that array and

\[ \mathtt{sizeof(*p)} = 4 \times 2 = 8\ \mathrm{bytes} \]

\[ \mathtt{MAXROW} \times 8 = 3 \times 8 = 24\ \mathrm{bytes} \]

The declaration is worth reading carefully: int (*p)[MAXCOL] is a pointer to an array, whereas int *p[MAXCOL] without the parentheses would be an array of pointers - a different type allocating a different amount.

Answer: C

Correct answer: The read-only data segment

String literals are placed in a read-only area loaded with the program image. Attempting to modify one through a char pointer compiles but produces undefined behaviour, usually a segmentation fault.

Answer: C

Correct answer: Heap area

malloc takes storage from the heap, a region the program grows at run time. That is what gives the block a lifetime independent of any function: it persists until free is called, whatever returns in the meantime.

The static area holds globals and static variables, laid out before the program starts, and the stack holds automatic variables, reclaimed on return. It is the heap's independence from function lifetimes that makes it the only place a data structure can be built and returned.

Answer: D

Correct answer: welcome

The calloc block is allocated and then immediately abandoned: assigning the string literal to p overwrites the only pointer to it. That is a memory leak, but it is not what the question asks about.

p now points at the literal "welcome", so that is what printf outputs. Note that the literal is not modifiable - writing through p afterwards would be undefined behaviour, which is why such a pointer is better declared const char *.

Answer: A

Correct answer: TRUE

malloc obtains storage from the heap, a region the program grows at run time through the operating system. That is what gives the block a lifetime independent of any function - it persists until free is called, whatever calls return in the meantime.

Stack storage behaves quite differently: it is allocated by the function prologue and reclaimed on return, which is why returning the address of a local is a fault and returning the result of malloc is not.

Answer: A

Correct answer: true

calloc sets every bit of the allocated block to zero, and the standard requires it. That is the guarantee, not a compiler-dependent convenience.

One subtlety is worth knowing: all-zero bits reliably give integer zero, but the standard does not promise that they give a null pointer or a floating-point zero - those hold on essentially every current implementation but are not guaranteed. Code depending on a zeroed block containing valid null pointers is portable in practice rather than in principle.

Answer: B

Correct answer: False

malloc() leaves the contents of the block indeterminate, so reading it before writing is undefined behaviour. calloc() is the function that clears the memory to zero, and it is the reason calloc() is preferred when a zeroed buffer is required.