What is the memory overhead when allocating 1000 integers vs 1 integer in a system with malloc metadata?

The correct answer is C: Fixed overhead per allocation regardless of size. Each malloc() call has fixed metadata overhead (typically 8-16 bytes). Single allocation of 1000 ints has less overhead than 1000 separate allocations.

What will this code do? int i = 0; while(i < 5) { printf("%d ", i++); if(i == 3) break; }

The correct answer is A: Prints: 0 1 2. Post-increment: prints 0 (i becomes 1), prints 1 (i becomes 2), prints 2 (i becomes 3). When i==3, break executes. Output: 0 1 2

A function needs to modify a variable in the calling function. Which parameter passing method is appropriate?

The correct answer is B: Pass by reference using pointers. To modify a variable in the calling function, you must pass its address (pointer). Pass by value creates a copy and cannot modify the original.

What is the critical issue with this code snippet? int *ptr = (int*)malloc(10); ptr[11] = 5;

The correct answer is A: Buffer overflow - accessing beyond allocated memory. malloc(10) allocates 10 bytes, but accessing ptr[11] goes beyond the allocated boundary, causing a buffer overflow which leads to undefined behavior and potential segmentation fault.

Which of the following is a valid declaration of a constant array?

The correct answer is D: Both A and B. Both declarations make the array elements constant. Option A initializes the array, while B declares it without initialization (valid at global scope).

Home

Home › Subjects › C Programming › Dynamic Memory

C Programming
Dynamic Memory

C language from basics to advanced placement prep

20 Q 10 Topics Take Mock Test

Difficulty: All Easy Medium Hard 11–20 of 20

Topics in C Programming

All Basics & Syntax 86 Data Types & Variables 97 Control Flow 100 Functions 99 Arrays & Strings 100 Pointers 99 Structures & Unions 100 File Handling 100 Dynamic Memory 98 Preprocessor 99

Q.11 Hard Dynamic Memory

For a program handling 10^6 integers dynamically, which allocation is most appropriate?

A int arr[1000000];

B int *arr = malloc(1000000 * sizeof(int));

C static int arr[1000000];

D auto int arr[1000000];

Correct Answer: B. int *arr = malloc(1000000 * sizeof(int));

EXPLANATION

Stack allocation (option A) will cause stack overflow. Dynamic allocation on heap is required for large data.

Test

Q.12 Hard Dynamic Memory

What distinguishes a dangling pointer?

A A pointer that points to deallocated memory

B A pointer initialized to NULL

C A pointer that hasn't been malloc'd

D A pointer that points to stack variable

Correct Answer: A. A pointer that points to deallocated memory

EXPLANATION

Dangling pointer points to memory that has been freed. Accessing it causes undefined behavior.

Test

Q.13 Hard Dynamic Memory

Consider this code:
int *p = malloc(sizeof(int));
int *q = p;
free(p);
q[0] = 5; // What is the result?

A Valid assignment

B Compiler error

C Use-after-free: undefined behavior

D Memory automatically reallocated

Correct Answer: C. Use-after-free: undefined behavior

EXPLANATION

Both p and q point to freed memory. Writing to q after free(p) is undefined behavior.

Test

Q.14 Hard Dynamic Memory

What is the risk in this code?
char *str = malloc(5);
strcpy(str, "Hello World");

A Memory leak (str not freed)

B Buffer overflow - writing 11 characters into 5 bytes

C strcpy() is deprecated

D Both A and B

Correct Answer: D. Both A and B

EXPLANATION

Buffer overflow occurs (11 chars into 5 bytes), and memory is never freed, causing a leak.

Test

Q.15 Hard Dynamic Memory

What is a common mistake in this code?
void func() {
int *ptr;
ptr = malloc(sizeof(int) * 5);
func2(ptr);
free(ptr);
}
void func2(int *p) {
free(p);
}

A Double free error - memory freed in both functions

B Memory leak - malloc without free

C Buffer overflow

D Segmentation fault guaranteed

Correct Answer: A. Double free error - memory freed in both functions

EXPLANATION

Memory is freed in func2(), then again in func(), causing double free error.

Test

Q.16 Hard Dynamic Memory

What does this realloc() call do?
int *p = malloc(5 * sizeof(int));
p = realloc(p, 10 * sizeof(int));

A Allocates new 10-integer block, discards old data

B Expands existing block to 10 integers, preserves old data

C Frees old block and allocates new one

D Returns error

Correct Answer: B. Expands existing block to 10 integers, preserves old data

EXPLANATION

realloc() resizes the memory block while preserving existing data. If expansion in-place fails, it allocates new block and copies data.

Test

Q.17 Hard Dynamic Memory

What is the correct way to allocate memory for 2D dynamic array (3x4)?

A int arr[3][4] = malloc(...);

B int **arr = malloc(3 * sizeof(int*)); for each row: malloc(4 * sizeof(int));

C int *arr = malloc(12 * sizeof(int));

D int arr = malloc(3*4*sizeof(int));

Correct Answer: B. int **arr = malloc(3 * sizeof(int*)); for each row: malloc(4 * sizeof(int));

EXPLANATION

For true 2D dynamic array, allocate pointer array first, then allocate each row. Option C is 1D linear allocation.

Test

Q.18 Hard Dynamic Memory

What is the issue in this code?
void func() {
int *p = malloc(sizeof(int));
*p = 5;
}
int main() {
func();
// p is not accessible here
return 0;
}

A Syntax error

B Memory leak - allocated memory is never freed

C Stack overflow

D No issue

Correct Answer: B. Memory leak - allocated memory is never freed

EXPLANATION

The pointer p is local to func(). Memory is allocated but never freed, causing a memory leak.

Test

Q.19 Hard Dynamic Memory

Which statement about dynamic memory is TRUE?

A Dynamic memory is faster than stack memory

B Dynamic memory persists until explicitly freed

C Dynamic memory is limited by cache size

D Dynamic memory is automatically freed at function end

Correct Answer: B. Dynamic memory persists until explicitly freed

EXPLANATION

Dynamic memory persists until free() is called, unlike automatic variables which are freed at function end.

Test

Q.20 Hard Dynamic Memory

What will happen if malloc() fails and returns NULL but code doesn't check?

A Program automatically allocates from stack

B Dereferencing NULL causes undefined behavior/crash

C Memory is automatically reallocated

D Exception is raised

Correct Answer: B. Dereferencing NULL causes undefined behavior/crash

EXPLANATION

Dereferencing a NULL pointer causes undefined behavior, typically resulting in segmentation fault or program crash.

Test

1 2

All Subjects & Topics

Govt. Exams

Entrance Exams

Teacher Exams

Subjects

Quick Links

C Programming Dynamic Memory

C Programming
Dynamic Memory