1

## 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:```
 A X—1 Y—3 Z-2 B (X—2 Y—1 Z-3 C X—3 Y—2 Z-1 D X—3 Y—1 Z-2
Dynamic Memory Allocation
Discuss it

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)
 A Only P3 B Only P1 and P3 C Only P1 and P2 D P1, P2 and P3
Dynamic Memory Allocation
Discuss it

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?
```# 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\n",*p);
return(0);
}
```
 A May not work B Works and prints 6
Dynamic Memory Allocation
Discuss it

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
 A calloc() allocates the memory and also initializes the allocates memory to zero, while memory allocated using malloc() has random data. B malloc() and memset() can be used to get the same effect as calloc(). C calloc() takes two arguments, but malloc takes only 1 argument. D Both malloc() and calloc() return 'void *' pointer. E All of the above
Dynamic Memory Allocation
Discuss it

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()
 A void * B Pointer of allocated memory type C void ** D int *
Dynamic Memory Allocation
Discuss it

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?
 A "ptr = calloc(m, n)" is equivalent to following ptr = malloc(m * n); B "ptr = calloc(m, n)" is equivalent to following ptr = malloc(m * n); memset(ptr, 0, m * n); C "ptr = calloc(m, n)" is equivalent to following ptr = malloc(m); memset(ptr, 0, m); D "ptr = calloc(m, n)" is equivalent to following ptr = malloc(n); memset(ptr, 0, n);
Dynamic Memory Allocation
Discuss it

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);
}
```
 A Compiler Error: free can't be applied on NULL pointer B Memory Leak C Dangling Pointer D The program may crash as free() is called for NULL pointer.
Dynamic Memory Allocation
Discuss it

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));
}
```
 A i, j and k are stored in stack segment B i and j are stored in stack segment. k is stored on heap. C i is stored in BSS part of data segment, j is stored in stack segment. k is stored on heap. D j is stored in BSS part of data segment, i is stored in stack segment. k is stored on heap.
Dynamic Memory Allocation
Discuss it

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
There are 8 questions to complete.
1

## GATE CS Corner

See Placement Course for placement preparation, GATE Corner for GATE CS Preparation and Quiz Corner for all Quizzes on GeeksQuiz.