C Programming - MCQ Practice Questions

Dereferencing a NULL pointer causes undefined behavior, typically resulting in segmentation fault or program crash.

Dynamic memory persists until free() is called, unlike automatic variables which are freed at function end.

The pointer p is local to func(). Memory is allocated but never freed, causing a memory leak.

For true 2D dynamic array, allocate pointer array first, then allocate each row. Option C is 1D linear allocation.

realloc() resizes the memory block while preserving existing data. If expansion in-place fails, it allocates new block and copies data.

Memory is freed in func2(), then again in func(), causing double free error.

Buffer overflow occurs (11 chars into 5 bytes), and memory is never freed, causing a leak.

Both p and q point to freed memory. Writing to q after free(p) is undefined behavior.

Dangling pointer points to memory that has been freed. Accessing it causes undefined behavior.

Stack allocation (option A) will cause stack overflow. Dynamic allocation on heap is required for large data.

Without freeing, allocated memory accumulates until system runs out of heap space, causing allocation failure or crash.

Large allocations may fail due to heap fragmentation or insufficient contiguous memory. Always check malloc() return for NULL.

"Hello World" is 11 bytes (including null terminator). Writing to 10-byte buffer causes buffer overflow, corrupting adjacent memory.

Single allocation with index tracking minimizes malloc/free overhead, suitable for competitive programming time constraints.

Doubling capacity and using realloc() provides amortized O(1) insertion with manageable memory overhead, which is the standard approach for dynamic data structures.

Checking if malloc returns NULL before using the pointer is essential error handling. If allocation fails, the program should handle it gracefully rather than proceeding with NULL.

While both work, inserting at beginning provides O(1) insertion; end requires traversal. Choice depends on use case.

Each malloc() call has fixed metadata overhead (typically 8-16 bytes). Single allocation of 1000 ints has less overhead than 1000 separate allocations.

Level-order traversal requires BFS which uses a queue. Dynamic queue allocation handles arbitrary tree sizes efficiently.

Contiguous allocation places array elements next to each other in memory, improving cache hits and CPU performance through spatial locality.