Dynamic Memory Allocation (DMA) : MCQs & PYQs with Explanation

Option C

If memory allocated using malloc() is not released using free(), the program causes a Memory Leak. A memory leak occurs when dynamically allocated heap memory is no longer needed but is not deallocated, and there is no pointer left to access it.
As a result, that memory remains reserved and cannot be reused during the program’s execution. Over time, repeated memory leaks can consume large amounts of RAM and may eventually Slow Down or Crash the system.

Option C

In the given program, memory is first allocated using malloc() for three integers and initialized correctly. Then realloc() is used to increase the memory size to store five integers, and the additional elements are assigned values properly. Up to this point, the program works correctly. 
However, the problem occurs at the end where free(ptr); is called twice. The first free() correctly deallocates the dynamically allocated heap memory, but the second free() attempts to release the same memory again. This results in Undefined Behavior, meaning the program may crash, corrupt memory, or behave unpredictably.

Option D

In C, when a pointer is freed using free(), the memory it was pointing to is deallocated, but the pointer itself is not automatically modified. It still holds the same address value as before. Therefore, the pointer’s value remains unchanged.
However, this pointer becomes a Dangling Pointer, because it points to memory that is no longer valid.

Option C

Here, the pointer p in main() is declared but not initialized. When fun(p) is called, the pointer is passed by value, meaning a copy of p is sent to the function. Inside fun(), memory is allocated to the local parameter a, but this change does not affect the original pointer p in main() because only a copy was modified. Therefore, after returning from fun(), the pointer p in main() still contains a garbage address.
When the statement *p=9; is executed, it attempts to dereference an uninitialized pointer, which results in undefined behaviour. The program may crash, may print some garbage value, or may behave unpredictably or may work on some systems.

Option C

In statement (X), memory is allocated using malloc(5), but immediately the pointer m is assigned NULL without freeing the allocated memory. This results is memory leak because the allocated heap memory no longer has any reference.
In statement (Y), memory is first freed using free(n);, but after freeing, the pointer is still used (n->value=5;). This is situation of Dangling Pointer, because the pointer refers to memory that has already been deallocated.
In statement (Z), a pointer p is declared but not initialized to any valid memory location. When *p='a'; is executed, it attempts to access memory through an uninitialized pointer, which leads to Undefined Behavior.

Option B

Here first memory is allocated dynamically using calloc(100,1) and the returned address is stored in the pointer ptr. 
However, in the next statement, ptr = "Suraku Academy"; the pointer is reassigned to point to a string literal instead of the allocated memory. This means the previously allocated memory becomes unused, but the pointer now correctly points to the string "Suraku Academy". 
When printf("%s",ptr); is executed, it prints the string stored at the address pointed to by ptr, which is "Suraku Academy".

Option B

[P1]
int* fun(void) 
{ 
  int x=10; 
  return(&x); 
}
Here, x is a local variable stored on the stack. Once the function returns, x goes out of scope and its memory becomes invalid. Returning the address of such a local variable results in a Dangling Pointer, which can cause undefined behavior.
Hence, P1 causes a pointer problem.
[P2]
int* fun(void) 
{ 
  int *px; 
  *px=10; 
  return px; 
}
In this case, px is an uninitialized pointer. No memory is allocated before dereferencing it using *px=10. This leads to undefined behavior and may cause a Segmentation Fault.
Hence, P2 causes a pointer problem.
[P3]
int* fun(void) 
{ 
  int *px; 
  px=(int *)malloc(sizeof(int)); 
  *px=10; 
  return px; 
}
Here, memory is correctly allocated using malloc(), the value is assigned properly, and the pointer returned is valid as long as the allocated memory is not freed.
Hence, P3 does NOT cause a pointer problem.

Option A

In the given code, memory is dynamically allocated using malloc() and its address is stored in the pointer ptr. Immediately after allocation, the pointer is set to NULL using ptr=NULL;. This causes the original memory address returned by malloc() to be lost, meaning there is no way to access or free that allocated memory anymore. 
As a result, the allocated memory remains unused and cannot be reclaimed, which leads to a Memory Leak.
Calling free(ptr) after setting ptr to NULL has no effect, because freeing a NULL pointer is safe but does nothing.

• A Dangling Pointer refers to accessing memory after it has been freed.
• A Wild Pointer is an uninitialized pointer.

Option B

In C, when realloc(ptr, 0) is called, it behaves like free(ptr). This means the previously allocated memory block is deallocated, and the memory is returned to the heap.
According to the C standard, if the new size passed to realloc() is zero and the pointer is not NULL, the memory is released.
Now, consider the one more special case, if ptr is NULL and size is not 0, then realloc() behaves exactly like malloc(size). That means it allocates a new block of memory of the given size and returns a pointer to it.

Option C

In C, the malloc() function attempts to allocate the requested amount of memory from the heap. If the memory allocation is successful, it returns a pointer to the beginning (base address) of the allocated block. However, if the allocation fails for any reason, malloc() returns NULL.
The same rule applies to other dynamic memory allocation functions such as calloc() and realloc().
If calloc() fails to allocate memory, it also returns NULL. Similarly, realloc() returns NULL if it cannot resize the memory block.