C Dynamic Memory Allocation

Question 1
The most appropriate matching for the following pairs (GATE CS 2000)
X: m=malloc(5); m= NULL;        1: using dangling pointers
Y: free(n); n->value=5;         2: using uninitialized pointers
Z: char *p; *p = ’a’;           3. lost memory is:
Cross
X—1 Y—3 Z-2
Cross
(X—2 Y—1 Z-3
Cross
X—3 Y—2 Z-1
Tick
X—3 Y—1 Z-2


Question 1-Explanation: 
X -> A pointer is assigned to NULL without freeing memory so a clear example of memory leak Y -> Trying to retrieve value after freeing it so dangling pointer. Z -> Using uninitialized pointers
Question 2
Consider the following three C functions :
[PI] int * g (void) 
{ 
  int x= 10; 
  return (&x); 
}  
  
[P2] int * g (void) 
{ 
  int * px; 
  *px= 10; 
  return px; 
} 
  
[P3] int *g (void) 
{ 
  int *px; 
  px = (int *) malloc (sizeof(int)); 
  *px= 10; 
  return px; 
}
Which of the above three functions are likely to cause problems with pointers? (GATE 2001)
Cross
Only P3
Cross
Only P1 and P3
Tick
Only P1 and P2
Cross
P1, P2 and P3


Question 2-Explanation: 
In P1, pointer variable x is a local variable to g(), and g() returns pointer to this variable. x may vanish after g() has returned as x exists on stack. So, &x may become invalid. In P2, pointer variable px is being assigned a value without allocating memory to it. P3 works perfectly fine. Memory is allocated to pointer variable px using malloc(). So, px exists on heap, it’s existence will remain in memory even after return of g() as it is on heap.
Question 3

Output? 

C

# include<stdio.h>
# include<stdlib.h>
 
void fun(int *a)
{
    a = (int*)malloc(sizeof(int));
}
 
int main()
{
    int *p;
    fun(p);
    *p = 6;
    printf("%d",*p);
    return(0);
}
Tick

May not work

Cross

Works and prints 6



Question 3-Explanation: 

The program is not valid. Try replacing “int *p;” with “int *p = NULL;” and it will try to dereference a null pointer. This is because fun() makes a copy of the pointer, so when malloc() is called, it is setting the copied pointer to the memory location, not p. p is pointing to random memory before and after the call to fun(), and when you dereference it, it will crash. If you want to add memory to a pointer from a function, you need to pass the address of the pointer (ie. double pointer).

Question 4
Which of the following is/are true
Cross
calloc() allocates the memory and also initializes the allocates memory to zero, while memory allocated using malloc() has random data.
Cross
malloc() and memset() can be used to get the same effect as calloc().
Cross
calloc() takes two arguments, but malloc takes only 1 argument.
Cross
Both malloc() and calloc() return \'void *\' pointer.
Tick
All of the above


Question 4-Explanation: 
All of the given options are true. See http://www.geeksforgeeks.org/calloc-versus-malloc/ for details.
Question 5
What is the return type of malloc() or calloc()
Tick
void *
Cross
Pointer of allocated memory type
Cross
void **
Cross
int *


Question 5-Explanation: 
malloc() and calloc() return void *. We may get warning in C if we don\'t type cast the return type to appropriate pointer.
Question 6
Which of the following is true?
Cross
\"ptr = calloc(m, n)\" is equivalent to following
ptr = malloc(m * n);
Tick
\"ptr = calloc(m, n)\" is equivalent to following
ptr = malloc(m * n); memset(ptr, 0, m * n);
Cross
\"ptr = calloc(m, n)\" is equivalent to following
ptr = malloc(m); memset(ptr, 0, m);
Cross
\"ptr = calloc(m, n)\" is equivalent to following
ptr = malloc(n); memset(ptr, 0, n);


Question 6-Explanation: 
See calloc() versus malloc() for details.
Question 7
What is the problem with following code?
#include<stdio.h>
int main()
{
    int *p = (int *)malloc(sizeof(int));

    p = NULL;

    free(p);
}
Cross
Compiler Error: free can\'t be applied on NULL pointer
Tick
Memory Leak
Cross
Dangling Pointer
Cross
The program may crash as free() is called for NULL pointer.


Question 7-Explanation: 
free() can be called for NULL pointer, so no problem with free function call. The problem is memory leak, p is allocated some memory which is not freed, but the pointer is assigned as NULL. The correct sequence should be following:
    free(p);
    p = NULL;
Question 8
Consider the following program, where are i, j and k are stored in memory?
int i;
int main()
{
    int j;
    int *k = (int *) malloc (sizeof(int));
}
Cross
i, j and *k are stored in stack segment
Cross
i and j are stored in stack segment. *k is stored on heap.
Tick
i is stored in BSS part of data segment, j is stored in stack segment. *k is stored on heap.
Cross
j is stored in BSS part of data segment, i is stored in stack segment. *k is stored on heap.


Question 8-Explanation: 
i is global variable and it is uninitialized so it is stored on BSS part of Data Segment (http://en.wikipedia.org/wiki/.bss) j is local in main() so it is stored in stack frame (http://en.wikipedia.org/wiki/Call_stack) *k is dynamically allocated so it is stored on Heap Segment. See following article for more details. Memory Layout of C Programs
Question 9

Which languages necessarily need heap allocation in the run time environment?

Cross

Those that support recursion

Cross

Those that use dynamic scoping

Cross

Those that use global variables

Tick

Those that allow dynamic data structures



Question 9-Explanation: 

Languages that allow dynamic data structures necessarily need heap allocation in the runtime environment. This is because dynamic data structures such as arrays, linked lists, trees, and graphs require memory allocation that persists beyond the lifetime of the function in which they are created. Heap allocation allows for the dynamic creation and destruction of memory blocks at runtime, which is essential for implementing dynamic data structures.

Question 10
We use malloc and calloc for
Tick
Dynamic memory allocation
Cross
Static memory allocation
Cross
Both dynamic and static memory allocation
Cross
None of the above


Question 10-Explanation: 
Both Calloc() and Malloc() are used for dynamic memory allocation. Refer: calloc() versus malloc()
There are 10 questions to complete.


  • Last Updated : 28 Sep, 2023

Share your thoughts in the comments
Similar Reads