Memory Allocation Questions and Answers

Q: How will you free the memory allocated by the following program? #include <stdio.h> #include <stdlib.h> #define MAXROW 3 #define MAXCOL 4 int main() { int **p, i, j; p = (int **) malloc(MAXROW * sizeof(int*)); return 0; }

Correct answer: free(p);The pointer that malloc returned is the one free must be given, so free(p) releases the block of row pointers.Note what has actually been allocated: only the array of MAXROW pointers. Had the rows themselves been allocated in a loop, each would need freeing individually before free(p) - releasing the outer array first would destroy the only record of the row addresses and leak every one of them.

Q: 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); }

Correct answer: May not workThe pointer is passed by value, so fun receives a copy. Assigning the result of malloc to that copy changes nothing in main, where p is still uninitialised.Writing *p = 6 then dereferences an indeterminate pointer, which is undefined behaviour - it may crash, may appear to work, may corrupt something else. To change the caller's pointer the function would need a int ** parameter, or it would have to return the new address.

Q: Can I increase the size of statically allocated array?

Correct answer: NoA statically allocated array has its size fixed when the program is compiled, and there is no mechanism to change it at run time.Obtaining a larger one means allocating fresh storage dynamically and copying the contents across - which is exactly what realloc does for heap blocks. This inflexibility is the principal reason dynamic allocation exists, and it is why every growable structure in C is built on the heap.

Q: What will be the output of the program? #include <stdio.h> #include <stdlib.h> int main() { union test { int i; float f; char c; }; union test *t; t = (union test *)malloc(sizeof(union test)); t->f = 10.10f; printf("%f", t->f); return 0; }

Correct answer: 10.100000The value is written to the union's float member and read back through the same member, so nothing is reinterpreted and the value is intact.It prints as 10.100000 because %f defaults to six decimal places. Remember that a union holds only one member at a time, all sharing the same storage: writing t->f destroys whatever t->i or t->c contained, and reading a different member afterwards would reinterpret the float's bits.

Q: Assume integer is 2 bytes wide. How many bytes will be allocated for the following code? #include <stdio.h> #include <stdlib.h> #define MAXROW 3 #define MAXCOL 4 int main() { int (*p)[MAXCOL]; p = (int (*) [MAXCOL])malloc(MAXROW *sizeof(*p)); return 0; }

Correct answer: 24 bytesp is a pointer to an array of MAXCOL integers, so *p is that array and\[ \mathtt{sizeof(*p)} = 4 \times 2 = 8\ \mathrm{bytes} \]\[ \mathtt{MAXROW} \times 8 = 3 \times 8 = 24\ \mathrm{bytes} \]The declaration is worth reading carefully: int (*p)[MAXCOL] is a pointer to an array, whereas int *p[MAXCOL] without the parentheses would be an array of pointers - a different type allocating a different amount.

Q: In which memory segment are string literals typically stored in a C program ?

Correct answer: The read-only data segmentString literals are placed in a read-only area loaded with the program image. Attempting to modify one through a char pointer compiles but produces undefined behaviour, usually a segmentation fault.

Q: Memory allocation using malloc() is done in?

Correct answer: Heap areamalloc takes storage from the heap, a region the program grows at run time. That is what gives the block a lifetime independent of any function: it persists until free is called, whatever returns in the meantime.The static area holds globals and static variables, laid out before the program starts, and the stack holds automatic variables, reclaimed on return. It is the heap's independence from function lifetimes that makes it the only place a data structure can be built and returned.

Q: What is the output of this C code? void main() { char *p = calloc(100, 1); p = "welcome"; printf("%s\n", p); }

Correct answer: welcomeThe calloc block is allocated and then immediately abandoned: assigning the string literal to p overwrites the only pointer to it. That is a memory leak, but it is not what the question asks about.p now points at the literal "welcome", so that is what printf outputs. Note that the literal is not modifiable - writing through p afterwards would be undefined behaviour, which is why such a pointer is better declared const char *.

31.

What is the main difference between malloc() and calloc() ?

A.calloc() allocates from the stack while malloc() uses the heap
B.calloc() initialises the allocated memory to zero while malloc() does not
C.calloc() can allocate only a single block while malloc() can allocate many
D.calloc() returns an int pointer while malloc() returns a void pointer

Answer: D

Correct answer: calloc() initialises the allocated memory to zero while malloc() does not

calloc() takes the number of elements and the size of each, and clears the whole block to zero before returning it. malloc() takes a single size in bytes and leaves the contents indeterminate, so reading them before assignment is undefined behaviour.

Discuss in Forum

32.

How will you free the memory allocated by the following program?

#include <stdio.h>
#include <stdlib.h>
#define MAXROW 3
#define MAXCOL 4

int main()
{
    int **p, i, j;
    p = (int **) malloc(MAXROW * sizeof(int*));
    return 0;
}

A.memfree(int p);
B.dealloc(p);
C.malloc(p, 0);
D.free(p);

Answer: D

Correct answer: free(p);

The pointer that malloc returned is the one free must be given, so free(p) releases the block of row pointers.

Note what has actually been allocated: only the array of MAXROW pointers. Had the rows themselves been allocated in a loop, each would need freeing individually before free(p) - releasing the outer array first would destroy the only record of the row addresses and leak every one of them.

Discuss in Forum

33.

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

Answer: A

Correct answer: May not work

The pointer is passed by value, so fun receives a copy. Assigning the result of malloc to that copy changes nothing in main, where p is still uninitialised.

Writing *p = 6 then dereferences an indeterminate pointer, which is undefined behaviour - it may crash, may appear to work, may corrupt something else. To change the caller's pointer the function would need a int ** parameter, or it would have to return the new address.

Discuss in Forum

34.

Can I increase the size of statically allocated array?

A.Yes
B.No

Answer: B

Correct answer: No

A statically allocated array has its size fixed when the program is compiled, and there is no mechanism to change it at run time.

Obtaining a larger one means allocating fresh storage dynamically and copying the contents across - which is exactly what realloc does for heap blocks. This inflexibility is the principal reason dynamic allocation exists, and it is why every growable structure in C is built on the heap.

Discuss in Forum

35.

A dangling pointer is one that ________.

A.has never been initialised
B.points to memory that has already been freed
C.points to a constant
D.has the value zero

Answer: A

Correct answer: points to memory that has already been freed

Calling free() releases the block but leaves the pointer holding its old address, and using it afterwards is undefined behaviour. Setting the pointer to NULL immediately after freeing it is the standard guard against this.

Discuss in Forum

36.

What will be the output of the program?

#include <stdio.h>
#include <stdlib.h>

int main()
{
    union test
    {
        int i;
        float f;
        char c;
    };
    union test *t;
    t = (union test *)malloc(sizeof(union test));
    t->f = 10.10f;
    printf("%f", t->f);
    return 0;
}

A.10
B.Garbage value
C.10.100000
D.Error

Answer: C

Correct answer: 10.100000

The value is written to the union's float member and read back through the same member, so nothing is reinterpreted and the value is intact.

It prints as 10.100000 because %f defaults to six decimal places. Remember that a union holds only one member at a time, all sharing the same storage: writing t->f destroys whatever t->i or t->c contained, and reading a different member afterwards would reinterpret the float's bits.

Discuss in Forum

37.

Assume integer is 2 bytes wide. How many bytes will be allocated for the following code?

#include <stdio.h>
#include <stdlib.h>
#define MAXROW 3
#define MAXCOL 4

int main()
{
    int (*p)[MAXCOL];
    p = (int (*) [MAXCOL])malloc(MAXROW *sizeof(*p));
    return 0;
}

A.56 bytes
B.128 bytes
C.24 bytes
D.12 bytes

Answer: C

Correct answer: 24 bytes

p is a pointer to an array of MAXCOL integers, so *p is that array and

\[ \mathtt{sizeof(*p)} = 4 \times 2 = 8\ \mathrm{bytes} \]

\[ \mathtt{MAXROW} \times 8 = 3 \times 8 = 24\ \mathrm{bytes} \]

The declaration is worth reading carefully: int (*p)[MAXCOL] is a pointer to an array, whereas int *p[MAXCOL] without the parentheses would be an array of pointers - a different type allocating a different amount.

Discuss in Forum

38.

In which memory segment are string literals typically stored in a C program ?

A.The stack
B.The heap
C.The read-only data segment
D.The uninitialised data segment

Answer: C

Correct answer: The read-only data segment

String literals are placed in a read-only area loaded with the program image. Attempting to modify one through a char pointer compiles but produces undefined behaviour, usually a segmentation fault.

Discuss in Forum

39.

Memory allocation using malloc() is done in?

A.Static area
B.Stack area
C.Heap area
D.Both b & c

Answer: C

Correct answer: Heap area

malloc takes storage from the heap, a region the program grows at run time. That is what gives the block a lifetime independent of any function: it persists until free is called, whatever returns in the meantime.

The static area holds globals and static variables, laid out before the program starts, and the stack holds automatic variables, reclaimed on return. It is the heap's independence from function lifetimes that makes it the only place a data structure can be built and returned.

Discuss in Forum

40.

What is the output of this C code?

void main()
{
char *p = calloc(100, 1);
p = "welcome";
printf("%s\n", p);
}

A.Segmentation fault
B.garbage
C.Error
D.welcome

Answer: D

Correct answer: welcome

The calloc block is allocated and then immediately abandoned: assigning the string literal to p overwrites the only pointer to it. That is a memory leak, but it is not what the question asks about.

p now points at the literal "welcome", so that is what printf outputs. Note that the literal is not modifiable - writing through p afterwards would be undefined behaviour, which is why such a pointer is better declared const char *.

Discuss in Forum

Loading…

Topics

Other Subjects

Tags: Memory Allocation Questions and Answers || Memory Allocation MCQ Questions and Answers || Memory Allocation GK Questions and Answers || Memory Allocation GK MCQ Questions || Memory Allocation Multiple Choice Questions and Answers || Memory Allocation GK || GK on Memory Allocation || C Programming Questions and Answers || C Programming MCQ Questions and Answers || C Programming GK Questions and Answers || GK on C Programming

Memory Allocation Questions and Answers

Topics

Other Subjects

About Us

Stay informed about all important Dates & Notifications