Memory Allocation Questions and Answers

Q: calloc() returns a storage that is initialized to.

Correct answer: Zerocalloc clears the block it returns, setting every byte to zero. That is its distinguishing feature, and the reason it is preferred where a zeroed structure or a counter array is wanted.A caution worth knowing: all-zero bytes give an integer value of zero and, on essentially every current implementation, a floating-point zero and a null pointer as well - but the standard guarantees only the integer case. Code that relies on a zeroed block containing valid null pointers is portable in practice rather than in principle.

Q: What will be the output of the program? #include <stdio.h> #include <stdlib.h> int main() { int *p; p = (int *)malloc(20); /* Assume p has address of 1314 */ free(p); printf("%u", p); return 0; }

Correct answer: 1314free takes its argument by value and does nothing to the caller's pointer. The bits in p are exactly what they were, so it still prints 1314.That is precisely what makes a dangling pointer dangerous: it looks entirely valid, and dereferencing it may appear to work while the freed block is untouched. The conventional discipline is to set the pointer to NULL immediately after freeing, so that a later misuse fails loudly rather than silently.

Q: Purpose of using fflush() function −

Correct answer: To flush all streams and specified streamsfflush(stream) writes out any buffered data for that stream, and fflush(NULL) flushes every output stream the program has open. Both forms are provided, which is what the option describes.Its normal use is to force output to appear when it would otherwise sit in the buffer - before a prompt, or before a crash. Note that fflush on an input stream is undefined behaviour in standard C, despite being widely and wrongly used to discard unread input.

Q: Point out the error of the following code − #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char* ptr; *ptr = (int*)malloc(30); strcpy(ptr, "ABC"); printf("%s", ptr); free(ptr); }

Correct answer: Error in *ptr = (int*)malloc(30);The asterisk is in the wrong place. ptr is a char *, so *ptr is a single char, and the line attempts to assign a pointer to it. The types are incompatible and the address is discarded even if the compiler is persuaded to accept it.The line should read ptr = malloc(30);. Everything after it then depends on this error: strcpy writes through a pointer that was never given a valid address, which is undefined behaviour.

Q: If malloc() successfully allocates memory it returns the number of bytes it has allocated.

Correct answer: FALSEmalloc returns a pointer to the allocated block, not a count of bytes. On success it is the address of the storage; on failure it is null.The number of bytes is what the caller supplied as the argument, so returning it would convey nothing. There is in fact no portable way to ask how large an allocated block is once it has been made, which is why programs that need to know must record the size themselves alongside the pointer.

Q: What will be the output of the program (16-bit platform)? #include <stdio.h> #include <stdlib.h> int main() { int *p; p = (int *)malloc(20); printf("%d\n", sizeof(p)); free(p); return 0; }

Correct answer: 2sizeof(p) gives the size of the pointer, not of the 20 bytes it points to. On the 16-bit platform the question specifies, a near pointer holds a 16-bit offset and occupies 2 bytes.The same expression gives 4 on a 32-bit build and 8 on a 64-bit one, which is why the platform has to be stated for the question to have an answer. There is no portable way to ask how large an allocated block is; a program that needs to know must record the size itself.

Q: On freeing a dynamic memory, if the pointer value is not modified, then the pointer points to?

Correct answer: The same deallocated memory locationfree receives the pointer by value and cannot alter the caller's copy, so the bits in the pointer are exactly what they were. It still holds the address of the block - which now belongs to the allocator again.This is a dangling pointer, and it is dangerous precisely because it looks valid and may appear to work while the freed block is untouched. Setting the pointer to NULL immediately after freeing is the standard discipline, since a null dereference fails immediately and visibly.

Q: We use malloc and calloc for

Correct answer: Dynamic memory allocationmalloc and calloc obtain storage at run time from the heap, in a quantity that may be computed rather than fixed in the source. That is what dynamic allocation means.Static allocation is settled by the compiler: globals and static variables are laid out before the program runs, and automatic variables are allocated by the function prologue. Neither requires a library call, which is the practical signal that they are a different mechanism. Dynamically allocated storage must be released with free; static storage never is.

Q: malloc() returns a float pointer if memory is allocated for storing float's and a double pointer if memory is allocated for storing double's. A.

Correct answer: FALSEmalloc returns void * regardless of what will be stored in the block. It has no way of knowing: the only argument it receives is a number of bytes.The conversion to float * or double * happens at the assignment, implicitly in C. What malloc does guarantee is that the block is suitably aligned for any type, which is what makes that later conversion safe whatever the caller has in mind.

51.

calloc() returns a storage that is initialized to.

A.Zero
B.Null
C.Nothing
D.One

Answer: A

Correct answer: Zero

calloc clears the block it returns, setting every byte to zero. That is its distinguishing feature, and the reason it is preferred where a zeroed structure or a counter array is wanted.

A caution worth knowing: all-zero bytes give an integer value of zero and, on essentially every current implementation, a floating-point zero and a null pointer as well - but the standard guarantees only the integer case. Code that relies on a zeroed block containing valid null pointers is portable in practice rather than in principle.

Discuss in Forum

52.

What will be the output of the program?

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

int main()
{
    int *p;
    p = (int *)malloc(20); /* Assume p has address of 1314 */
    free(p);
    printf("%u", p);
    return 0;
}

A.1314
B.Garbage value
C.1316
D.Random address

Answer: A

Correct answer: 1314

free takes its argument by value and does nothing to the caller's pointer. The bits in p are exactly what they were, so it still prints 1314.

That is precisely what makes a dangling pointer dangerous: it looks entirely valid, and dereferencing it may appear to work while the freed block is untouched. The conventional discipline is to set the pointer to NULL immediately after freeing, so that a later misuse fails loudly rather than silently.

Discuss in Forum

53.

Purpose of using fflush() function −

A.To flush all streams and specified streams
B.To flush only specified streams
C.To flush input-output buffer
D.This is invalid library function

Answer: A

Correct answer: To flush all streams and specified streams

fflush(stream) writes out any buffered data for that stream, and fflush(NULL) flushes every output stream the program has open. Both forms are provided, which is what the option describes.

Its normal use is to force output to appear when it would otherwise sit in the buffer - before a prompt, or before a crash. Note that fflush on an input stream is undefined behaviour in standard C, despite being widely and wrongly used to discard unread input.

Discuss in Forum

54.

Point out the error of the following code −

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
   char* ptr;
   *ptr = (int*)malloc(30);
   strcpy(ptr, "ABC");
   printf("%s", ptr);
   free(ptr);
}

A.Error in strcpy() statement
B.Error in *ptr = (int*)malloc(30);
C.Error in free(ptr)
D.No Error

Answer: B

Correct answer: Error in *ptr = (int*)malloc(30);

The asterisk is in the wrong place. ptr is a char *, so *ptr is a single char, and the line attempts to assign a pointer to it. The types are incompatible and the address is discarded even if the compiler is persuaded to accept it.

The line should read ptr = malloc(30);. Everything after it then depends on this error: strcpy writes through a pointer that was never given a valid address, which is undefined behaviour.

Discuss in Forum

55.

What is the output of this program?

#include <stdio.h>
#include <stdlib.h>
int main()
{
 struct test
 {
   int i;
   float f;
   char c;
 };
 struct test *ptr;
 ptr = (struct test *)malloc(sizeof(struct test));
 ptr ->f = 5.5f;
 printf("%f", ptr->f);
 return 0;
}

A.5.5
B.5
C.5.5

Answer: C

Here test is a structure name which consist of three variables of three different data types. ptr is the pointer variable, for which the memory is allocated dynamically by using malloc() of function and then it is pointed towards the structure floating variable f. Now f is initialized with a value 5.5f and then outputted as 5.500000.

Discuss in Forum

56.

If malloc() successfully allocates memory it returns the number of bytes it has allocated.

A.True
B.False

Answer: B

Correct answer: FALSE

malloc returns a pointer to the allocated block, not a count of bytes. On success it is the address of the storage; on failure it is null.

The number of bytes is what the caller supplied as the argument, so returning it would convey nothing. There is in fact no portable way to ask how large an allocated block is once it has been made, which is why programs that need to know must record the size themselves alongside the pointer.

Discuss in Forum

57.

What will be the output of the program (16-bit platform)?

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

int main()
{
    int *p;
    p = (int *)malloc(20);
    printf("%d\n", sizeof(p));
    free(p);
    return 0;
}

A.4
B.2
C.7
D.Garbage value

Answer: B

Correct answer: 2

sizeof(p) gives the size of the pointer, not of the 20 bytes it points to. On the 16-bit platform the question specifies, a near pointer holds a 16-bit offset and occupies 2 bytes.

The same expression gives 4 on a 32-bit build and 8 on a 64-bit one, which is why the platform has to be stated for the question to have an answer. There is no portable way to ask how large an allocated block is; a program that needs to know must record the size itself.

Discuss in Forum

58.

On freeing a dynamic memory, if the pointer value is not modified, then the pointer points to?

A.NULL
B.Other dynamically allocated memory
C.The same deallocated memory location
D.It points back to location it was initialized with

Answer: C

Correct answer: The same deallocated memory location

free receives the pointer by value and cannot alter the caller's copy, so the bits in the pointer are exactly what they were. It still holds the address of the block - which now belongs to the allocator again.

This is a dangling pointer, and it is dangerous precisely because it looks valid and may appear to work while the freed block is untouched. Setting the pointer to NULL immediately after freeing is the standard discipline, since a null dereference fails immediately and visibly.

Discuss in Forum

59.

We use malloc and calloc for

A.Dynamic memory allocation
B.Static memory allocation
C.Both dynamic and static memory allocation
D.None of the above

Answer: A

Correct answer: Dynamic memory allocation

malloc and calloc obtain storage at run time from the heap, in a quantity that may be computed rather than fixed in the source. That is what dynamic allocation means.

Static allocation is settled by the compiler: globals and static variables are laid out before the program runs, and automatic variables are allocated by the function prologue. Neither requires a library call, which is the practical signal that they are a different mechanism. Dynamically allocated storage must be released with free; static storage never is.

Discuss in Forum

60.

malloc() returns a float pointer if memory is allocated for storing float's and a double pointer if memory is allocated for storing double's. A.

A.TRUE
B.FALSE
C.May Be
D.Can't Say

Answer: B

Correct answer: FALSE

malloc returns void * regardless of what will be stored in the block. It has no way of knowing: the only argument it receives is a number of bytes.

The conversion to float * or double * happens at the assignment, implicitly in C. What malloc does guarantee is that the block is suitably aligned for any type, which is what makes that later conversion safe whatever the caller has in mind.

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