Pointers and Memory Management Interview Questions for C Programming with DSA
25 Pointers and Memory Management questions with answers for c programming with dsa roles — 7 easy, 12 medium, 6 hard.
About Pointers and Memory Management
Pointers are the most important and most feared C topic. Learn addresses, pointer arithmetic, pointers with arrays and functions, double pointers, function pointers, malloc, calloc, realloc and free, stack versus heap, memory leaks, dangling pointers and how to debug segmentation faults with GDB, Valgrind and AddressSanitizer.
Sheet progressStart practicing
3 QUESTIONS FREESign up to unlock the full question bank and track your progress.Unlock every question and answer, then continue practising company-wise and package-wise.
A pointer is a variable that stores the memory address of another variable. int *p = &x; makes p hold the address of x, and *p reads or writes the value at that address. Pointers allow passing large data efficiently, modifying caller variables, working with arrays and strings, building dynamic data structures like linked lists and allocating memory at runtime.
A null pointer holds NULL and points to nothing; dereferencing it crashes. A dangling pointer points to memory that has been freed or a local that went out of scope. A wild pointer is uninitialised and holds a random address. A void pointer is a generic pointer that can hold any object address but must be cast before dereferencing, as malloc returns void *.
03
What is the difference between malloc, calloc, realloc and free?
malloc(size) allocates uninitialised memory. calloc(n, size) allocates memory for n elements and sets all bytes to zero, and it checks n times size for overflow. realloc(ptr, size) resizes a block, possibly moving it, and returns the new address. free(ptr) releases memory back to the allocator. All allocators return NULL on failure, so always check the result.
04
What is the difference between stack and heap allocation?
Stack memory holds local variables, is allocated and freed automatically when functions enter and return, and is very fast but limited in size, often 1 to 8 MB. Heap memory is allocated with malloc and freed manually, can be large and outlive the function, but is slower and can fragment or leak. Large or variable sized data and data that must outlive a function belong on the heap.
05
Write a function that dynamically allocates an array of n integers and fills it with squares.
Check the allocation and let the caller free it.
int *makeSquares(size_t n) {
int *arr = malloc(n * sizeof *arr);
if (arr == NULL) return NULL;
for (size_t i = 0; i < n; i++) {
arr[i] = (int)(i * i);
}
return arr;
}
// caller
int *a = makeSquares(10);
if (a) { /* use */ free(a); }
06
Write a function that swaps two integers using pointers.
Pass addresses so the function can modify the caller's variables.
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main(void) {
int x = 3, y = 7;
swap(&x, &y);
printf("%d %d\n", x, y); // 7 3
return 0;
}
C passes everything by value, so pointers are needed to change caller data.
07
What does sizeof return for a pointer and for an array?
sizeof on a pointer returns the size of the pointer itself, typically 8 bytes on a 64-bit system, regardless of what it points to. sizeof on an array declared in the same scope returns the total bytes of all elements, so sizeof arr / sizeof arr[0] gives the element count. Inside a function receiving an array parameter, sizeof returns pointer size, so pass the length separately.
Adding an integer to a pointer moves it by that many elements, not bytes, so p + 1 on an int pointer advances by sizeof(int). Subtracting two pointers into the same array gives the number of elements between them as ptrdiff_t. Arithmetic is valid only within an array or one past its end; going further is undefined behaviour. Void pointer arithmetic is not allowed in standard C.
09
What is the difference between an array and a pointer?
An array is a block of contiguous elements whose size is fixed and known to the compiler; sizeof gives the full array size. A pointer is a variable holding an address; sizeof gives the pointer size. An array name decays to a pointer to its first element in most expressions, but it cannot be reassigned. When passed to a function, an array always becomes a pointer, losing its length.
A memory leak happens when dynamically allocated memory is never freed and the last pointer to it is lost, so the program keeps growing in memory use. Long running services and embedded systems eventually fail. Detect leaks with Valgrind memcheck, AddressSanitizer with LeakSanitizer or allocation tracking wrappers. Prevent them with clear ownership rules and a single cleanup path per function.
A function pointer stores the address of a function, declared like int (*op)(int, int) = add;, and called with op(2, 3). It enables callbacks such as the comparator in qsort, dispatch tables replacing long switch statements, plugin interfaces and state machines in embedded code. Using typedef makes function pointer types much more readable.
A double pointer, such as int **pp, stores the address of a pointer. It is needed when a function must change the caller's pointer itself, for example inserting at the head of a linked list or allocating memory inside a function and returning it through a parameter. It is also used for dynamic 2D arrays and arrays of strings, like char **argv.
13
A program crashes with a segmentation fault. How do you find the cause?
Compile with -g and run under gdb; when it crashes, use bt to see the call stack and print variables in the failing frame. Common causes are dereferencing NULL, using freed memory, out-of-bounds array access and stack overflow from deep recursion. Building with -fsanitize=address gives a precise report of the bad access and where the memory was allocated or freed.
14
A function returns the address of a local array and the caller gets wrong data. Why?
Local arrays live on the stack and are destroyed when the function returns, so the returned pointer is dangling and later calls overwrite that memory. Fix it by having the caller pass a buffer and its size, allocating with malloc and documenting that the caller must free it, or using a static buffer, which is not thread safe. Compilers warn about this with -Wreturn-local-addr.
15
After calling realloc, the program sometimes crashes. What could be wrong?
realloc may move the block and returns the new address, so old pointers to the block become invalid. Writing ptr = realloc(ptr, n) also leaks the original memory if realloc fails and returns NULL. Store the result in a temporary pointer, check for NULL, then assign. Make sure no other pointers still refer to the old location after a successful move.
16
Allocate and free a dynamic 2D array of rows by cols in C.
A single block is cache friendly and easy to free.
int (*grid)[cols] = malloc(rows * sizeof *grid);
if (!grid) return -1;
grid[2][3] = 5;
free(grid);
// array of row pointers alternative
int **m = malloc(rows * sizeof *m);
for (int i = 0; i < rows; i++)
m[i] = calloc(cols, sizeof **m);
for (int i = 0; i < rows; i++) free(m[i]);
free(m);
The first form uses a variable length array type.
17
Use qsort with a function pointer to sort an array of integers in descending order.
Write a comparator that returns negative, zero or positive.
int cmpDesc(const void *a, const void *b) {
int x = *(const int *)a;
int y = *(const int *)b;
return (y > x) - (y < x);
}
int arr[] = {4, 1, 9, 3};
qsort(arr, 4, sizeof arr[0], cmpDesc);
Returning y - x can overflow, so the comparison form is safer.
Situation: a C based telemetry agent grew by 200 MB a day on customer servers. Task: find and fix the leak quickly. Action: I reproduced it with recorded traffic under Valgrind and found that an error path returned early without freeing a parsed message buffer. I restructured the function with a single cleanup label and added a leak check job to CI. Result: memory stayed flat for weeks after the patch.
19
How do you write C code that other developers can maintain?
Situation: I inherited a 3000 line C file with global variables everywhere. Task: make it safe to extend. Action: I split it into modules with clear headers, made helpers static, documented ownership of every allocated pointer, added unit tests with a small framework and followed a consistent style enforced by clang-format. Result: new features took half the time and code reviews became much faster.
Strict aliasing says an object may be accessed only through an lvalue of its own type, a compatible type or a character type. Reading a float through an int pointer breaks the rule and is undefined behaviour, and optimisers at -O2 may reorder or drop such accesses. To reinterpret bytes safely, use memcpy into a variable of the other type, or a union, which GCC supports for type punning.
Alignment means placing data at addresses that are multiples of its size or required boundary, such as 4 for int. CPUs read aligned data faster, and some architectures fault on misaligned access. Compilers add padding in structs to align members. You can check alignment with _Alignof and request it with _Alignas or aligned_alloc in C11.
22
Memory use of a long running C service grows every hour. How do you investigate?
Run it under Valgrind or with AddressSanitizer and LeakSanitizer in a test environment and reproduce typical traffic, then read the leak report with allocation stack traces. In production, compare heap usage over time with tools like heaptrack. Check error paths that return early without free, lost pointers after realloc, and caches without size limits. Fix ownership and add a leak check to CI.
23
Valgrind reports invalid read of size 4 after free. How do you fix it?
This is a use-after-free: code reads memory that was already released. Valgrind shows where it was freed and where it was read. Fix the ownership logic so nothing uses the object after free, and set pointers to NULL right after freeing so accidental use fails fast. If multiple parts share the object, use reference counting or free only at one clear owner.
Copy byte by byte through unsigned char pointers.
void *my_memcpy(void *dest, const void *src, size_t n) {
unsigned char *d = dest;
const unsigned char *s = src;
while (n--) {
*d++ = *s++;
}
return dest;
}
memcpy must not be used for overlapping regions; memmove handles overlap by copying backwards when needed. Real libraries copy whole words for speed.
25
Write a simple fixed-size memory pool allocator in C.
A free list of equal blocks avoids malloc in hot or embedded paths.
#define BLOCKS 64
typedef union Block { union Block *next; char data[32]; } Block;
static Block pool[BLOCKS];
static Block *freeList;
void poolInit(void) {
for (int i = 0; i < BLOCKS - 1; i++) pool[i].next = &pool[i + 1];
pool[BLOCKS - 1].next = NULL;
freeList = pool;
}
void *poolAlloc(void) {
Block *b = freeList;
if (b) freeList = b->next;
return b;
}
void poolFree(void *p) {
Block *b = p; b->next = freeList; freeList = b;
}
Frequently asked questions
How important is Pointers and Memory Management in C Programming with DSA interviews?
Pointers are the most important and most feared C topic. Learn addresses, pointer arithmetic, pointers with arrays and functions, double pointers, function pointers, malloc, calloc, realloc and free, stack versus heap, memory leaks, dangling pointers and how to debug segmentation faults with GDB, Valgrind and AddressSanitizer.
How should I use the Pointers and Memory Management sheet?
Go top to bottom — easy to hard. Answer before opening each answer, tick what you solved and save misses to Last-Minute Revision.