What is dynamic memory allocation in C?

Dynamic memory allocation in C refers to allocating memory at runtime using functions such as malloc, calloc, realloc, and free from the stdlib.h library. This allows for more flexible and efficient memory management compared to static allocation.

How do you allocate memory dynamically in C?

To allocate memory dynamically in C, use the malloc function. For example, int *ptr = (int *)malloc(sizeof(int)); allocates memory for one integer and assigns its address to the pointer ptr.

What is the difference between malloc and calloc in C?

The malloc function allocates a specified number of bytes of uninitialized memory, while the calloc function allocates memory for an array of elements and initializes all bytes to zero. For example, int *ptr = (int *)calloc(10, sizeof(int)); allocates memory for an array of 10 integers and initializes them to zero.

How do you resize dynamically allocated memory in C?

To resize dynamically allocated memory in C, use the realloc function. For example, int *new_ptr = (int *)realloc(ptr, new_size); changes the size of the memory block pointed to by ptr to new_size bytes, and returns a pointer to the new memory block.

How do you free dynamically allocated memory in C?

To free dynamically allocated memory in C, use the free function. For example, free(ptr); deallocates the memory pointed to by ptr, making it available for future use.

What happens if you forget to free dynamically allocated memory in C?

Forgetting to free dynamically allocated memory in C leads to memory leaks, where memory is allocated but not deallocated, reducing the amount of available memory for the program and potentially causing it to crash.

Can you dynamically allocate memory for arrays in C?

Yes, you can dynamically allocate memory for arrays in C using malloc or calloc. For example, int *arr = (int *)malloc(n * sizeof(int)); allocates memory for an array of n integers.

How do you avoid memory leaks in C?

To avoid memory leaks in C, ensure that every call to malloc, calloc, or realloc has a corresponding call to free. Regularly review your code to verify that all dynamically allocated memory is properly deallocated.

What is the purpose of the realloc function in C?

The realloc function in C is used to resize an existing block of dynamically allocated memory. It adjusts the memory size while preserving the content up to the minimum of the old and new sizes.

How does the malloc function work in C?

The malloc function in C allocates a specified number of bytes of uninitialized memory and returns a pointer to the allocated memory. If the allocation fails, it returns a NULL pointer.

What is the syntax for using calloc in C?

The syntax for using calloc in C is: void *calloc(size_t num, size_t size); where num is the number of elements and size is the size of each element. It returns a pointer to the allocated memory.

How does dynamic memory allocation improve program flexibility?

Dynamic memory allocation improves program flexibility by allowing memory to be allocated as needed during runtime. This enables the creation of dynamic data structures such as linked lists, queues, and trees.

What is the difference between static and dynamic memory allocation in C?

Static memory allocation in C is determined at compile time, while dynamic memory allocation occurs at runtime. Static allocation has fixed size and cannot change, whereas dynamic allocation can be resized as needed using malloc, calloc, realloc, and free.

Can you allocate memory for a 2D array dynamically in C?

Yes, you can allocate memory for a 2D array dynamically in C. For example, int **arr = (int **)malloc(rows * sizeof(int *)); followed by a loop to allocate memory for each row using malloc.

How do you handle dynamic memory allocation errors in C?

To handle dynamic memory allocation errors in C, always check if the pointer returned by malloc, calloc, or realloc is NULL. If it is NULL, handle the error appropriately, such as displaying an error message and terminating the program.

How is dynamic memory managed in C?

Dynamic memory in C is managed using pointers and functions from the stdlib.h library. Memory is allocated using malloc, calloc, and realloc, and deallocated using free to ensure efficient use of memory.

Can you allocate memory for strings dynamically in C?

Yes, you can allocate memory for strings dynamically in C using malloc. For example, char *str = (char *)malloc(n * sizeof(char)); allocates memory for a string of n characters.

Where can I find practice MCQs on dynamic memory allocation in C?

For practice MCQs on dynamic memory allocation in C, visit gkaim.com. The website offers a variety of multiple-choice questions and detailed explanations to help you master dynamic memory allocation concepts.

How does gkaim.com help in understanding dynamic memory allocation?

gkaim.com helps in understanding dynamic memory allocation by providing comprehensive MCQs, detailed explanations, and examples. The website's resources are designed to enhance your learning and mastery of dynamic memory allocation in C programming.

Dynamic Memory Allocation MCQs - Part 1 »🤔Think Critically

Q: What is a memory leak in C programming?

A memory leak in C programming occurs when dynamically allocated memory is not properly deallocated using the free function. This leads to wasted memory resources and can cause the program to run out of memory over time.

Home » Programming Languages » C Programming » Dynamic Memory Allocation MCQs » Part 1 » 100 Questions

Timer: Off

Random: Off

1. Which function is used to allocate memory dynamically in C?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: malloc()

Explanation: The `malloc()` function is used to allocate a specified number of bytes of memory during the execution of a program.

2. Which function is used to allocate and initialize memory in C?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: calloc()

Explanation: The `calloc()` function allocates memory for an array of elements, initializes them to zero, and then returns a pointer to the memory.

3. What does the `realloc()` function do in C?

ⓐ. Allocate memory

ⓑ. Deallocate memory

ⓒ. Reallocate memory

ⓓ. Initialize memory

Correct Answer: Reallocate memory

Explanation: The `realloc()` function changes the size of previously allocated memory block to a new size.

4. Which function is used to deallocate memory in C?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: free()

Explanation: The `free()` function is used to release memory that was previously allocated using `malloc()`, `calloc()`, or `realloc()`.

5. What will happen if you try to free memory that has already been freed?

ⓐ. The program will run normally

ⓑ. It will cause a memory leak

ⓒ. It may cause undefined behavior

ⓓ. It will reallocate the memory

Correct Answer: It may cause undefined behavior

Explanation: Freeing already freed memory can lead to undefined behavior, including crashes or data corruption.

6. Which header file must be included to use dynamic memory allocation functions in C?

ⓐ. <stdio.h>

ⓑ. <stdlib.h>

ⓒ. <string.h>

ⓓ. <math.h>

Correct Answer: <stdlib.h>

Explanation: The <stdlib.h> header file contains the declarations for memory allocation functions such as `malloc()`, `calloc()`, `realloc()`, and `free()`.

7. What is the return type of the `malloc()` function?

ⓐ. void

ⓑ. int

ⓒ. void*

ⓓ. char*

Correct Answer: void*

Explanation: The `malloc()` function returns a pointer of type `void*` which can be cast to any other pointer type.

8. If `malloc()` fails to allocate the requested memory, what does it return?

ⓐ. 0

ⓑ. NULL

ⓒ. -1

ⓓ. A pointer to random memory

Correct Answer: NULL

Explanation: When `malloc()` fails to allocate the requested memory, it returns NULL to indicate the failure.

9. How can you resize a dynamically allocated array in C?

ⓐ. Using `malloc()`

ⓑ. Using `calloc()`

ⓒ. Using `realloc()`

ⓓ. Using `free()`

Correct Answer: Using `realloc()`

Explanation: The `realloc()` function is used to resize a previously allocated memory block to a new size.

10. Which function can be used to allocate memory for an array of integers and initialize them to zero?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: calloc()

Explanation: The `calloc()` function allocates memory for an array and initializes all its bits to zero.

11. What does the following code do? `int *ptr = (int*)malloc(sizeof(int) * 10);`

ⓐ. Allocates memory for 10 integers

ⓑ. Allocates memory for 1 integer

ⓒ. Allocates memory for 10 characters

ⓓ. Allocates memory for 1 character

Correct Answer: Allocates memory for 10 integers

Explanation: The `malloc` function allocates a block of memory. `sizeof(int) * 10` calculates the amount of memory needed for 10 integers. The `(int*)` cast converts the void pointer returned by `malloc` to an integer pointer. This way, `ptr` can be used as an array of 10 integers.

12. What will happen if there is insufficient memory for `malloc` to allocate the requested memory?

ⓐ. The program will crash

ⓑ. The program will run with an error

ⓒ. `malloc` will return NULL

ⓓ. `malloc` will retry until memory is available

Correct Answer: `malloc` will return NULL

Explanation: If `malloc` is unable to allocate the requested memory, it returns a NULL pointer. This indicates that the memory allocation failed. It is good practice to always check if the returned pointer is NULL before using it to avoid dereferencing a NULL pointer, which can lead to program crashes.

13. What does the following code do? `free(ptr);`

ⓐ. Allocates memory pointed to by `ptr`

ⓑ. Deallocates memory pointed to by `ptr`

ⓒ. Changes the size of memory pointed to by `ptr`

ⓓ. Initializes memory pointed to by `ptr`

Correct Answer: Deallocates memory pointed to by `ptr`

Explanation: The `free` function deallocates the memory that was previously allocated by `malloc`, `calloc`, or `realloc`. After calling `free`, the pointer `ptr` becomes a dangling pointer, meaning it points to a memory location that is no longer valid. It is a good practice to set the pointer to NULL after freeing it to avoid accidental usage.

14. Why is it necessary to free dynamically allocated memory?

ⓐ. To prevent memory leaks

ⓑ. To increase execution speed

ⓒ. To optimize CPU usage

ⓓ. To make code more readable

Correct Answer: To prevent memory leaks

Explanation: Dynamically allocated memory that is not freed results in a memory leak. A memory leak occurs when a program loses the ability to free the memory that is no longer needed, which can lead to increased memory usage and eventually cause the program or system to run out of memory. This is especially critical in long-running applications or systems with limited memory resources.

15. What is the difference between `malloc` and `calloc`?

ⓐ. `malloc` initializes memory to zero, while `calloc` does not

ⓑ. `malloc` allocates memory without initializing, while `calloc` allocates and initializes memory to zero

ⓒ. `calloc` is faster than `malloc`

ⓓ. `malloc` is used for arrays, `calloc` is used for single variables

Correct Answer: `malloc` allocates memory without initializing, while `calloc` allocates and initializes memory to zero

Explanation: `malloc` allocates a block of memory but does not initialize it, meaning it contains garbage values. In contrast, `calloc` allocates memory and initializes all bits to zero. `calloc` is often used when initializing arrays or buffers where a zero-initialized block of memory is needed.

16. What is a memory leak in C programming?

ⓐ. When allocated memory is not accessible

ⓑ. When memory allocation fails

ⓒ. When a program crashes due to insufficient memory

ⓓ. When the operating system reclaims memory

Correct Answer: When allocated memory is not accessible

Explanation: A memory leak occurs when a program allocates memory dynamically but fails to deallocate it before losing the reference to that memory. This results in the allocated memory being inaccessible and unusable for the program, effectively reducing the amount of available memory. Over time, memory leaks can exhaust the available memory, leading to performance degradation or program crashes.

17. What is the use of the `sizeof` operator in dynamic memory allocation?

ⓐ. To determine the amount of memory to allocate

ⓑ. To free allocated memory

ⓒ. To initialize allocated memory

ⓓ. To reallocate memory

Correct Answer: To determine the amount of memory to allocate

Explanation: The `sizeof` operator is used to determine the size in bytes of a data type or object. When using `malloc` or `calloc` to allocate memory, `sizeof` ensures that the correct amount of memory is allocated for the specified data type. For example, `sizeof(int)` returns the size of an integer in bytes, ensuring that the allocated memory block is large enough to store the intended data.

18. Which of the following statements about `realloc` is true?

ⓐ. `realloc` can only increase the size of the allocated memory

ⓑ. `realloc` can only decrease the size of the allocated memory

ⓒ. `realloc` can both increase and decrease the size of the allocated memory

ⓓ. `realloc` cannot change the size of the allocated memory

Correct Answer: `realloc` can both increase and decrease the size of the allocated memory

Explanation: The `realloc` function can be used to resize a previously allocated memory block. It can increase the size of the memory block if more space is needed or decrease the size if less space is required. If the new size is larger, `realloc` may move the memory block to a new location if there is not enough contiguous space at the current location, copying the existing data to the new block.

19. What happens to the original memory block if `realloc` moves the memory to a new location?

ⓐ. It remains allocated

ⓑ. It is automatically freed

ⓒ. It is filled with zeros

ⓓ. It is returned to the system

Correct Answer: It is automatically freed

Explanation: When `realloc` moves the memory block to a new location, the original memory block is automatically freed. This ensures that there are no memory leaks when resizing memory. However, if `realloc` fails to allocate the new block, the original block remains unchanged, and `realloc` returns NULL, allowing the program to handle the allocation failure without losing the original data.

20. What should be done after calling `free` on a dynamically allocated memory?

ⓐ. Set the pointer to NULL

ⓑ. Reallocate memory immediately

ⓒ. Call `calloc` to reset memory

ⓓ. Do nothing

Correct Answer: Set the pointer to NULL

Explanation: After calling `free` on a dynamically allocated memory block, it is a good practice to set the pointer to NULL. This prevents the pointer from becoming a dangling pointer, which points to a memory location that has been deallocated. Accessing a dangling pointer can lead to undefined behavior, including program crashes and data corruption. Setting the pointer to NULL ensures that any accidental dereference can be detected easily.

21. Which function would you use to allocate memory for a 2D array dynamically?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: calloc()

Explanation: The `calloc` function is often used for allocating memory for arrays, including 2D arrays, because it initializes the allocated memory to zero. This is particularly useful when you need to ensure that all elements in the array are initialized to zero before using them. `calloc` takes two arguments: the number of elements and the size of each element.

22. How do you allocate memory for a string of 50 characters in C?

ⓐ. char *str = (char*)malloc(50);

ⓑ. char *str = (char*)malloc(50 * sizeof(char));

ⓒ. char *str = (char*)calloc(50);

ⓓ. char *str = (char*)realloc(NULL, 50);

Correct Answer: char *str = (char*)malloc(50 * sizeof(char));

Explanation: To allocate memory for a string of 50 characters, you need to allocate 50 bytes (assuming 1 byte per character). The expression `50 * sizeof(char)` ensures that the memory allocation is correctly sized for 50 characters. The `malloc` function allocates the required memory, and the `(char*)` cast converts the void pointer returned by `malloc` to a char pointer.

23. What will happen if you call `free` on a NULL pointer?

ⓐ. The program will crash

ⓑ. The program will run normally

ⓒ. It will cause a memory leak

ⓓ. It will reallocate the memory

Correct Answer: The program will run normally

Explanation: Calling `free` on a NULL pointer is safe and has no effect. The C standard specifies that if the pointer passed to `free` is NULL, no action occurs. This makes it safe to `free` pointers that might be NULL without needing to check if they are NULL first.

24. Which function is used to dynamically allocate memory that will later be resized?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: realloc()

Explanation: The `realloc` function is used to resize a previously allocated memory block. It can increase or decrease the size of the allocated memory. This is useful when you initially allocate a memory block with `malloc` or `calloc` and later determine that you need more or less memory.

25. What does the following code do? `int *arr = (int*)realloc(NULL, 10 * sizeof(int));`

ⓐ. Frees memory pointed to by `arr`

ⓑ. Allocates memory for 10 integers

ⓒ. Changes size of memory block to 10 integers

ⓓ. Initializes an array of 10 integers to zero

Correct Answer: Allocates memory for 10 integers

Explanation: The `realloc` function can also be used to allocate memory when the first argument is NULL. This behavior is equivalent to calling `malloc`. In this case, `realloc(NULL, 10 * sizeof(int))` allocates memory for 10 integers, similar to `malloc(10 * sizeof(int))`.

26. What should be checked immediately after calling `malloc` or `calloc`?

ⓐ. If the allocated memory is zero

ⓑ. If the returned pointer is NULL

ⓒ. If the memory was freed

ⓓ. If the memory was initialized

Correct Answer: If the returned pointer is NULL

Explanation: After calling `malloc` or `calloc`, it is crucial to check if the returned pointer is NULL. A NULL pointer indicates that the memory allocation failed, which can happen if there is not enough memory available. Failing to check for a NULL pointer and proceeding to use it can lead to dereferencing a NULL pointer, causing the program to crash.

27. What is the correct way to allocate memory for a structure in C?

ⓐ. struct MyStruct *ptr = malloc(sizeof(struct MyStruct));

ⓑ. struct MyStruct *ptr = (struct MyStruct*)malloc(sizeof(struct MyStruct));

ⓒ. struct MyStruct *ptr = malloc(sizeof(MyStruct));

ⓓ. struct MyStruct *ptr = (MyStruct*)malloc(sizeof(MyStruct));

Correct Answer: struct MyStruct *ptr = (struct MyStruct*)malloc(sizeof(struct MyStruct));

Explanation: When allocating memory for a structure, you use the `sizeof` operator to determine the size of the structure. The `malloc` function allocates the required memory, and the `(struct MyStruct*)` cast converts the void pointer returned by `malloc` to a pointer of the correct type. This ensures that the pointer can be used to access the structure’s members correctly.

28. How do you allocate memory for an array of 10 floats and initialize them to zero?

ⓐ. float *arr = (float*)malloc(10 * sizeof(float));

ⓑ. float *arr = (float*)calloc(10, sizeof(float));

ⓒ. float *arr = (float*)realloc(NULL, 10 * sizeof(float));

ⓓ. float *arr = (float*)calloc(10 * sizeof(float));

Correct Answer: float *arr = (float*)calloc(10, sizeof(float));

Explanation: The `calloc` function is used to allocate memory for an array and initialize all its elements to zero. The first argument specifies the number of elements, and the second argument specifies the size of each element. In this case, `calloc(10, sizeof(float))` allocates memory for 10 floats and initializes all elements to zero.

29. What is the result of using `free` on a memory block that was not dynamically allocated?

ⓐ. The memory block is freed

ⓑ. The program runs normally

ⓒ. Undefined behavior occurs

ⓓ. The memory block is reallocated

Correct Answer: Undefined behavior occurs

Explanation: Using `free` on a memory block that was not dynamically allocated (e.g., a stack-allocated variable) results in undefined behavior. This can cause the program to crash, corrupt data, or exhibit other unexpected behavior. It is essential to only `free` memory that was allocated dynamically using `malloc`, `calloc`, or `realloc`.

30. What is a potential issue when using `realloc` to shrink the size of a memory block?

ⓐ. The memory block is not resized

ⓑ. The excess memory is not freed

ⓒ. Data beyond the new size is lost

ⓓ. The program crashes

Correct Answer: Data beyond the new size is lost

Explanation: When using `realloc` to shrink the size of a memory block, any data stored beyond the new size is lost. `realloc` may move the memory block to a new location and copy only the data that fits within the new size. It is essential to ensure that no important data exists beyond the new size before shrinking the memory block to avoid data loss.

31. What is a memory leak in the context of C programming?

ⓐ. Allocating memory multiple times

ⓑ. Not allocating enough memory

ⓒ. Allocating memory and not freeing it

ⓓ. Using stack memory instead of heap memory

Correct Answer: Allocating memory and not freeing it

Explanation: A memory leak occurs when a program allocates memory dynamically using functions like `malloc`, `calloc`, or `realloc` and fails to free that memory using `free` when it is no longer needed. Over time, this can lead to a depletion of available memory, which can cause the program or system to run out of memory and potentially crash.

32. Which of the following practices helps prevent memory leaks?

ⓐ. Always using stack memory

ⓑ. Frequently calling `malloc`

ⓒ. Freeing dynamically allocated memory when it is no longer needed

ⓓ. Allocating more memory than needed

Correct Answer: Freeing dynamically allocated memory when it is no longer needed

Explanation: To prevent memory leaks, it is crucial to free dynamically allocated memory once it is no longer required. This can be done using the `free` function. Failing to do so keeps the memory allocated and inaccessible for future use, leading to memory leaks.

33. How can tools like Valgrind help in managing memory leaks in C programs?

ⓐ. They allocate memory more efficiently

ⓑ. They automatically free unused memory

ⓒ. They detect memory leaks and memory usage errors

ⓓ. They optimize code execution

Correct Answer: They detect memory leaks and memory usage errors

Explanation: Tools like Valgrind are used to detect memory leaks, memory usage errors, and other memory-related issues in C programs. Valgrind can help identify places in the code where memory is allocated but not freed, where memory is accessed after being freed, and other common mistakes that lead to memory leaks and bugs.

34. Which of the following is a common sign of a memory leak in a running program?

ⓐ. Increased CPU usage

ⓑ. Decreased disk space

ⓒ. Gradually increasing memory usage over time

ⓓ. Faster program execution

Correct Answer: Gradually increasing memory usage over time

Explanation: A common sign of a memory leak is that the memory usage of the program gradually increases over time, even if the workload remains constant. This happens because the program is continuously allocating memory without freeing it, leading to a steady increase in memory consumption.

35. How can the use of smart pointers in C++ help avoid memory leaks?

ⓐ. By preventing memory allocation

ⓑ. By automatically freeing memory when it is no longer needed

ⓒ. By optimizing memory allocation

ⓓ. By increasing memory usage efficiency

Correct Answer: By automatically freeing memory when it is no longer needed

Explanation: Smart pointers in C++ (such as `std::unique_ptr` and `std::shared_ptr`) automatically manage the lifetime of dynamically allocated memory. When a smart pointer goes out of scope, it automatically frees the memory it points to, preventing memory leaks. This automatic management reduces the risk of forgetting to free memory manually.

36. What is the purpose of the `atexit` function in C with respect to memory management?

ⓐ. To allocate memory at program startup

ⓑ. To execute cleanup functions at program termination

ⓒ. To reallocate memory during program execution

ⓓ. To initialize memory at program startup

Correct Answer: To execute cleanup functions at program termination

Explanation: The `atexit` function in C allows you to register one or more functions to be called when the program terminates. These functions can perform necessary cleanup tasks, such as freeing dynamically allocated memory, closing files, and other resource management activities. This helps ensure that resources are properly released even if the program exits unexpectedly.

37. Why is it important to set a pointer to NULL after freeing the memory it points to?

ⓐ. To reduce memory usage

ⓑ. To prevent reallocation of the same memory

ⓒ. To avoid dangling pointer dereferencing

ⓓ. To increase execution speed

Correct Answer: To avoid dangling pointer dereferencing

Explanation: After freeing the memory pointed to by a pointer, setting the pointer to NULL helps prevent accidental dereferencing of the now-invalid pointer. Dereferencing a dangling pointer (a pointer that points to freed memory) can lead to undefined behavior, such as program crashes and data corruption. Setting the pointer to NULL ensures that any attempts to use it will result in a null pointer dereference, which is easier to detect and debug.

38. How can circular references lead to memory leaks?

ⓐ. By preventing memory allocation

ⓑ. By making memory inaccessible for deallocation

ⓒ. By increasing memory usage

ⓓ. By slowing down memory access

Correct Answer: By making memory inaccessible for deallocation

Explanation: Circular references occur when two or more objects reference each other, forming a cycle. In garbage-collected languages, this can prevent the memory from being freed, as the reference count of the objects never reaches zero. In C, circular references can occur with custom memory management schemes, making it difficult to determine when it is safe to free the memory, potentially leading to memory leaks.

39. What is the primary cause of memory leaks in programs that use dynamic memory allocation?

ⓐ. Allocating too much memory

ⓑ. Not allocating enough memory

ⓒ. Failing to free allocated memory

ⓓ. Using stack memory instead of heap memory

Correct Answer: Failing to free allocated memory

Explanation: The primary cause of memory leaks in programs that use dynamic memory allocation is failing to free allocated memory when it is no longer needed. This oversight leads to memory that is no longer accessible but still allocated, reducing the amount of available memory and potentially causing the program or system to run out of memory.

40. How can you ensure that dynamically allocated memory is always freed, even if an error occurs?

ⓐ. By using a static memory allocation

ⓑ. By manually tracking all allocations and deallocations

ⓒ. By using error handling techniques like `goto` for cleanup

ⓓ. By avoiding dynamic memory allocation

Correct Answer: By using error handling techniques like `goto` for cleanup

Explanation: One way to ensure that dynamically allocated memory is always freed, even if an error occurs, is to use error handling techniques like `goto` to jump to a cleanup section of the code. This section can contain code to free all allocated memory and perform other cleanup tasks. Using `goto` for cleanup helps centralize the cleanup code and ensures that resources are properly released in case of errors.

41. Which of the following functions does not initialize the allocated memory to zero?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: malloc()

Explanation: The `malloc` function allocates memory but does not initialize it. The allocated memory contains garbage values. If you need the memory to be initialized to zero, you should use `calloc`, which allocates and initializes the memory to zero.

42. What will be the content of memory allocated by `malloc`?

ⓐ. All zeros

ⓑ. All ones

ⓒ. Uninitialized (garbage values)

ⓓ. Random numbers

Correct Answer: Uninitialized (garbage values)

Explanation: Memory allocated by `malloc` is not initialized, which means it contains garbage values. The content of the memory will be whatever was present at that location before the allocation. If initialization to zero is needed, `calloc` should be used instead.

43. How can memory fragmentation be minimized in C programming?

ⓐ. By using larger memory blocks

ⓑ. By freeing memory in the reverse order of allocation

ⓒ. By avoiding dynamic memory allocation

ⓓ. By using static memory allocation

Correct Answer: By freeing memory in the reverse order of allocation

Explanation: Memory fragmentation can be minimized by freeing memory in the reverse order of allocation, known as LIFO (Last In, First Out). This helps keep large contiguous blocks of free memory available, reducing fragmentation. Fragmentation occurs when there are many small, non-contiguous free memory blocks, making it difficult to allocate large blocks of memory.

44. Which function is used to copy memory from one location to another?

ⓐ. memcpy()

ⓑ. malloc()

ⓒ. realloc()

ⓓ. calloc()

Correct Answer: memcpy()

Explanation: The `memcpy` function is used to copy a specified number of bytes from one memory location to another. It takes three arguments: the destination pointer, the source pointer, and the number of bytes to copy. It is useful for copying data between dynamically allocated memory blocks.

45. What does the `realloc` function return if the new size is zero?

ⓐ. NULL

ⓑ. The original pointer

ⓒ. A pointer to a new memory block

ⓓ. A pointer to the original memory block

Correct Answer: NULL

Explanation: If the new size specified in `realloc` is zero, the function frees the memory block and returns NULL. This effectively acts as a call to `free` for the given pointer. It is important to handle this case to avoid dereferencing a NULL pointer.

46. What is the effect of using `realloc` on a NULL pointer?

ⓐ. It behaves like `free`

ⓑ. It causes a segmentation fault

ⓒ. It behaves like `malloc`

ⓓ. It returns the original pointer

Correct Answer: It behaves like `malloc`

Explanation: When `realloc` is called with a NULL pointer, it behaves like `malloc`. It allocates a new block of memory of the specified size and returns a pointer to it. This is useful for initially allocating memory and resizing it later if needed.

47. What is the primary purpose of the `free` function in C?

ⓐ. To allocate memory

ⓑ. To reallocate memory

ⓒ. To deallocate previously allocated memory

ⓓ. To initialize memory

Correct Answer: To deallocate previously allocated memory

Explanation: The `free` function is used to deallocate memory that was previously allocated by `malloc`, `calloc`, or `realloc`. It releases the memory back to the system so that it can be reused by other parts of the program or other programs. Failing to use `free` can result in memory leaks.

48. How can double freeing of memory be avoided in C?

ⓐ. By using `malloc` instead of `calloc`

ⓑ. By setting the pointer to NULL after `free`

ⓒ. By using static memory allocation

ⓓ. By avoiding dynamic memory allocation

Correct Answer: By setting the pointer to NULL after `free`

Explanation: Double freeing occurs when `free` is called more than once on the same pointer, which can lead to undefined behavior and program crashes. To avoid this, it is good practice to set the pointer to NULL immediately after freeing it. This ensures that any subsequent calls to `free` on that pointer will have no effect.

49. What is the significance of the `sizeof` operator in dynamic memory allocation?

ⓐ. It determines the size of memory to allocate

ⓑ. It initializes allocated memory

ⓒ. It frees allocated memory

ⓓ. It reallocates memory

Correct Answer: It determines the size of memory to allocate

Explanation: The `sizeof` operator is used to determine the size in bytes of a data type or object. This is essential in dynamic memory allocation to ensure that the correct amount of memory is allocated. For example, `sizeof(int)` returns the size of an integer in bytes, which can be used to allocate memory for an array of integers.

50. Which function would you use to allocate memory for an array of 100 integers and ensure all elements are set to zero?

ⓐ. malloc()

ⓑ. calloc()

ⓒ. realloc()

ⓓ. free()

Correct Answer: calloc()

Explanation: The `calloc` function allocates memory for an array of a specified number of elements and initializes all elements to zero. For example, `calloc(100, sizeof(int))` allocates memory for 100 integers and initializes each integer to zero. This is useful for ensuring that all elements in the array are initially set to a known value.

51. What does the following code do?


int *arr;
arr = (int*)malloc(10 * sizeof(int));
if (arr != NULL) {
    for (int i = 0; i < 10; i++) {
        arr[i] = i;
    }
}

ⓐ. Allocates memory for an array of 10 integers and initializes them to their index values

ⓑ. Allocates memory for 10 integers and sets them all to zero

ⓒ. Allocates memory for a single integer and initializes it to zero

ⓓ. Allocates memory for 10 integers without initializing them

Correct Answer: Allocates memory for an array of 10 integers and initializes them to their index values

Explanation: The code allocates memory for an array of 10 integers using `malloc`. It then checks if the allocation was successful and initializes each element of the array to its index value using a for loop.

52. What is the output of the following code if `malloc` fails to allocate memory?


char *str;
str = (char*)malloc(20 * sizeof(char));
if (str == NULL) {
    printf("Memory allocation failed\n");
} else {
    strcpy(str, "Hello, World!");
    printf("%s\n", str);
}
free(str);

ⓐ. Hello, World!

ⓑ. Memory allocation failed

ⓒ. Segmentation fault

ⓓ. No output

Correct Answer: Memory allocation failed

Explanation: If `malloc` fails to allocate memory, it returns NULL. The code checks if `str` is NULL and prints "Memory allocation failed" if it is. Otherwise, it copies "Hello, World!" into `str` and prints it. Since the question specifies the scenario where `malloc` fails, the output will be "Memory allocation failed".

53. Which of the following correctly reallocates memory for an array of 5 integers to hold 10 integers?

ⓐ. `int *arr = (int*)realloc(arr, 10 * sizeof(int));`

ⓑ. `int *arr = (int*)realloc(NULL, 10 * sizeof(int));`

ⓒ. `int *arr = (int*)realloc(arr, 5 * sizeof(int));`

ⓓ. `int *arr = (int*)realloc(arr, 15 * sizeof(int));`

Correct Answer: `int *arr = (int*)realloc(arr, 10 * sizeof(int));`

Explanation: The `realloc` function is used to resize an allocated memory block. The correct way to reallocate memory for an array of 5 integers to hold 10 integers is `realloc(arr, 10 * sizeof(int))`, which adjusts the size of the memory block to accommodate 10 integers.

54. What will happen if you attempt to access an element beyond the allocated memory using `malloc`?


int *arr;
arr = (int*)malloc(5 * sizeof(int));
arr[5] = 10;

ⓐ. The program will run normally

ⓑ. The program will print 10

ⓒ. Undefined behavior

ⓓ. The program will allocate more memory automatically

Correct Answer: Undefined behavior

Explanation: Accessing an element beyond the allocated memory (in this case, `arr[5]`) leads to undefined behavior. The memory allocated by `malloc` is only guaranteed to be accessible within the specified size. Accessing outside of this range can result in program crashes, data corruption, or other unpredictable behavior.

55. Which of the following correctly frees dynamically allocated memory?


float *ptr;
ptr = (float*)malloc(5 * sizeof(float));
/* Some code that uses ptr */
free(ptr);

ⓐ. `free(*ptr);`

ⓑ. `free(ptr);`

ⓒ. `free(&ptr);`

ⓓ. `free(ptr*);`

Correct Answer: `free(ptr);`

Explanation: The `free` function is used to deallocate memory that was previously allocated with `malloc`, `calloc`, or `realloc`. The correct way to free the memory pointed to by `ptr` is `free(ptr);`. This releases the memory back to the system.

56. What will the following code print?


int *p = (int*)malloc(sizeof(int));
if (p == NULL) {
    printf("Memory allocation failed\n");
} else {
    *p = 42;
    printf("%d\n", *p);
}
free(p);

ⓐ. Memory allocation failed

ⓑ. 42

ⓒ. Undefined behavior

ⓓ. 0

Correct Answer: 42

Explanation: The code allocates memory for a single integer and assigns it the value 42. It then prints the value pointed to by `p`, which is 42. If the memory allocation fails, it prints "Memory allocation failed". Since the allocation is assumed to be successful in this scenario, the output will be 42.

57. Which statement is true about the following code?


int *arr;
arr = (int*)malloc(5 * sizeof(int));
free(arr);
free(arr);

ⓐ. The program will run normally

ⓑ. The program will free memory twice without issues

ⓒ. The program will cause undefined behavior

ⓓ. The program will reallocate the memory

Correct Answer: The program will cause undefined behavior

Explanation: Calling `free` on a pointer more than once (double free) results in undefined behavior. This can lead to program crashes, memory corruption, and other unpredictable issues. After freeing a pointer, it should not be freed again.

58. What does the following code do?


int *ptr;
ptr = (int*)calloc(5, sizeof(int));
for (int i = 0; i < 5; i++) {
    printf("%d ", ptr[i]);
}
free(ptr);

ⓐ. Prints five uninitialized values

ⓑ. Prints five zeros

ⓒ. Causes a segmentation fault

ⓓ. Prints garbage values

Correct Answer: Prints five zeros

Explanation: The `calloc` function allocates memory for an array of 5 integers and initializes all elements to zero. The for loop prints each element of the array, resulting in five zeros being printed. The memory is then freed using `free`.

59. What does the following code snippet illustrate?


int *arr1 = (int*)malloc(5 * sizeof(int));
int *arr2 = (int*)realloc(arr1, 10 * sizeof(int));

ⓐ. Allocating memory for an array of 10 integers

ⓑ. Allocating memory for an array of 5 integers

ⓒ. Resizing the memory block for `arr1` to hold 10 integers

ⓓ. Initializing an array of 10 integers to zero

Correct Answer: Resizing the memory block for `arr1` to hold 10 integers

Explanation: The code snippet shows the use of `realloc` to resize the memory block pointed to by `arr1` from 5 integers to 10 integers. The `realloc` function adjusts the size of the previously allocated memory block and returns a pointer to the new memory block.

60. Which of the following statements is true about dynamically allocated memory in C?

ⓐ. Memory allocated with `malloc` must be initialized manually

ⓑ. Memory allocated with `calloc` contains garbage values

ⓒ. Memory allocated with `realloc` cannot be resized

ⓓ. Memory allocated with `malloc` is automatically freed at program termination

Correct Answer: Memory allocated with `malloc` must be initialized manually

Explanation: Memory allocated with `malloc` is not initialized and contains garbage values. It must be initialized manually if initialization is needed. In contrast, `calloc` initializes the allocated memory to zero. Memory allocated with `realloc` can be resized, and dynamically allocated memory must be explicitly freed using `free`; it is not automatically freed at program termination.

61. What is the output of the following code?


int *arr;
arr = (int*)malloc(3 * sizeof(int));
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
free(arr);
printf("%d\n", arr[1]);

ⓐ. 1

ⓑ. 2

ⓒ. 3

ⓓ. Undefined behavior

Correct Answer: Undefined behavior

Explanation: After calling `free`, the memory pointed to by `arr` is deallocated, and accessing it results in undefined behavior. Therefore, the code may print any value or crash.

62. What will be the output of the following code snippet?


int *p;
p = (int*)malloc(sizeof(int));
if (p == NULL) {
    printf("Memory allocation failed\n");
    return 1;
}
*p = 100;
printf("%d\n", *p);
free(p);

ⓐ. Memory allocation failed

ⓑ. 100

ⓒ. Undefined behavior

ⓓ. Segmentation fault

Correct Answer: 100

Explanation: The code allocates memory for an integer, assigns the value 100 to it, and prints this value. Since memory allocation is assumed to be successful, the output will be 100.

63. What does the following code do?


int *ptr;
ptr = (int*)calloc(4, sizeof(int));
if (ptr != NULL) {
    for (int i = 0; i < 4; i++) {
        printf("%d ", ptr[i]);
    }
    free(ptr);
}

ⓐ. Prints four uninitialized values

ⓑ. Prints four zeros

ⓒ. Causes a segmentation fault

ⓓ. Prints garbage values

Correct Answer: Prints four zeros

Explanation: The `calloc` function allocates memory for an array of 4 integers and initializes all elements to zero. The for loop prints each element of the array, resulting in four zeros being printed.

64. What is the effect of the following code?


int *a, *b;
a = (int*)malloc(5 * sizeof(int));
b = a;
free(a);
free(b);

ⓐ. Double free error

ⓑ. Memory leak

ⓒ. Correctly frees memory

ⓓ. Causes a segmentation fault

Correct Answer: Double free error

Explanation: Both `a` and `b` point to the same allocated memory. Calling `free` on both `a` and `b` results in a double free error, which leads to undefined behavior, potentially causing the program to crash.

65. What is the output of this code?


char *str;
str = (char*)malloc(6 * sizeof(char));
strcpy(str, "Hello");
free(str);
printf("%s\n", str);

ⓐ. Hello

ⓑ. Memory allocation failed

ⓒ. Undefined behavior

ⓓ. Null

Correct Answer: Undefined behavior

Explanation: After freeing `str`, the memory is deallocated, and accessing it (as in `printf("%s\n", str)`) results in undefined behavior. The program may print any value or crash.

66. What is the purpose of the following code?


int *p = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    p[i] = i * i;
}
p = (int*)realloc(p, 10 * sizeof(int));
for (int i = 5; i < 10; i++) {
    p[i] = i * i;
}
for (int i = 0; i < 10; i++) {
    printf("%d ", p[i]);
}
free(p);

ⓐ. Allocates memory for 10 integers and initializes them to zero

ⓑ. Allocates memory for 5 integers, then reallocates it to 10 integers and initializes with squares of indices

ⓒ. Allocates memory for 5 integers and initializes them with squares of indices

ⓓ. Causes a memory leak

Correct Answer: Allocates memory for 5 integers, then reallocates it to 10 integers and initializes with squares of indices

Explanation: The code first allocates memory for 5 integers and initializes them to the squares of their indices. It then reallocates memory to hold 10 integers, initializes the new elements to the squares of their indices, and prints the entire array.

67. What does the following code print?


int *arr;
arr = (int*)malloc(3 * sizeof(int));
if (arr == NULL) {
    printf("Memory allocation failed\n");
    return 1;
}
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
free(arr);
arr = (int*)malloc(3 * sizeof(int));
printf("%d\n", arr[1]);
free(arr);

ⓐ. Memory allocation failed

ⓑ. 20

ⓒ. 0

ⓓ. Undefined behavior

Correct Answer: Undefined behavior

Explanation: After freeing `arr`, allocating memory again for `arr` does not guarantee that it will point to the same memory block. Accessing `arr[1]` after reallocation results in undefined behavior because the new memory block is uninitialized.

68. What is the output of this code if `realloc` fails to allocate memory?


int *arr = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = i;
}
int *new_arr = (int*)realloc(arr, 10 * sizeof(int));
if (new_arr == NULL) {
    printf("Reallocation failed\n");
    free(arr);
    return 1;
}
for (int i = 5; i < 10; i++) {
    new_arr[i] = i;
}
for (int i = 0; i < 10; i++) {
    printf("%d ", new_arr[i]);
}
free(new_arr);

ⓐ. Prints numbers 0 to 4

ⓑ. Reallocation failed

ⓒ. Prints numbers 0 to 9

ⓓ. Undefined behavior

Correct Answer: Reallocation failed

Explanation: If `realloc` fails, it returns NULL and does not free the original memory block. The code checks if `new_arr` is NULL and prints "Reallocation failed" if it is. Since the question specifies the scenario where `realloc` fails, the output will be "Reallocation failed".

69. What does the following code do?


int *arr;
arr = (int*)calloc(5, sizeof(int));
if (arr != NULL) {
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);
}

ⓐ. Prints five uninitialized values

ⓑ. Prints five zeros

ⓒ. Causes a segmentation fault

ⓓ. Prints garbage values

Correct Answer: Prints five zeros

70. What will be the effect of this code?


int *arr = (int*)malloc(3 * sizeof(int));
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
free(arr);
arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = arr[i] + 1;
}
for (int i = 0; i < 3; i++) {
    printf("%d ", arr[i]);
}
free(arr);

ⓐ. Prints 2 3 4

ⓑ. Causes a segmentation fault

ⓒ. Prints 1 2 3

ⓓ. Undefined behavior

Correct Answer: Undefined behavior

Explanation: After calling `free`, the memory pointed to by `arr` is deallocated. The subsequent `malloc` call allocates new memory, which is uninitialized. The code attempts to access and modify the uninitialized values, leading to undefined behavior.

71. What does the following code snippet do?


int *ptr = NULL;
ptr = (int*)malloc(4 * sizeof(int));
if (ptr != NULL) {
    for (int i = 0; i < 4; i++) {
        ptr[i] = i * 10;
    }
    free(ptr);
    ptr = NULL;
}

ⓐ. Allocates memory for 4 integers and leaves them uninitialized

ⓑ. Allocates memory for 4 integers, initializes them, frees the memory, and sets pointer to NULL

ⓒ. Causes a segmentation fault

ⓓ. Allocates memory for 4 integers and does nothing with it

Correct Answer: Allocates memory for 4 integers, initializes them, frees the memory, and sets pointer to NULL

Explanation: The code allocates memory for 4 integers and initializes each element to `i * 10`. After that, it frees the allocated memory and sets the pointer to NULL, which is a good practice to avoid dangling pointers.

72. What will be the output of the following code?


int *arr = (int*)malloc(2 * sizeof(int));
arr[0] = 5;
arr[1] = 10;
arr = (int*)realloc(arr, 3 * sizeof(int));
arr[2] = 15;
printf("%d %d %d\n", arr[0], arr[1], arr[2]);
free(arr);

ⓐ. 5 10 0

ⓑ. 5 10 15

ⓒ. 5 10 Garbage value

ⓓ. Causes a segmentation fault

Correct Answer: 5 10 15

Explanation: The `realloc` function resizes the allocated memory to hold 3 integers. The existing values are preserved, and the new element is initialized to 15. The code prints 5, 10, and 15 as expected.

73. What does the following code print?


char *str = (char*)malloc(6 * sizeof(char));
strcpy(str, "Hello");
str = (char*)realloc(str, 12 * sizeof(char));
strcat(str, " World");
printf("%s\n", str);
free(str);

ⓐ. Hello

ⓑ. Hello World

ⓒ. Hello WorldHello

ⓓ. Causes a segmentation fault

Correct Answer: Hello World

Explanation: The `realloc` function resizes the allocated memory to hold 12 characters. The existing string "Hello" is preserved, and " World" is concatenated to it. The code prints "Hello World".

74. What is the output of this code?


int *arr = (int*)malloc(3 * sizeof(int));
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
free(arr);
arr = NULL;
printf("%d\n", arr == NULL);

ⓐ. 1

ⓑ. 0

ⓓ. Undefined behavior

Correct Answer: 1

Explanation: After freeing the allocated memory, the pointer `arr` is set to NULL. The `printf` statement checks if `arr` is NULL, which is true, so it prints 1.

75. What does the following code do?


int *a = (int*)malloc(5 * sizeof(int));
if (a == NULL) {
    printf("Memory allocation failed\n");
    return 1;
}
int *b = (int*)malloc(5 * sizeof(int));
if (b == NULL) {
    printf("Memory allocation failed\n");
    free(a);
    return 1;
}
memcpy(b, a, 5 * sizeof(int));
free(a);
free(b);

ⓐ. Allocates memory for two arrays and copies contents from `a` to `b`

ⓑ. Allocates memory for two arrays and leaves them uninitialized

ⓓ. Allocates memory for one array and frees it

Correct Answer: Allocates memory for two arrays and copies contents from `a` to `b`

Explanation: The code allocates memory for two arrays of 5 integers each. It uses `memcpy` to copy the contents of `a` to `b`, then frees both memory blocks. If any allocation fails, it handles the failure gracefully by freeing the previously allocated memory.

76. What is the purpose of this code snippet?


int *p;
p = (int*)calloc(5, sizeof(int));
if (p != NULL) {
    for (int i = 0; i < 5; i++) {
        printf("%d ", p[i]);
    }
    free(p);
}

ⓐ. Allocates memory for 5 integers and leaves them uninitialized

ⓑ. Allocates memory for 5 integers, initializes them to zero, and prints them

ⓓ. Allocates memory for 5 integers and initializes them with index values

Correct Answer: Allocates memory for 5 integers, initializes them to zero, and prints them

Explanation: The `calloc` function allocates memory for 5 integers and initializes all elements to zero. The for loop prints each element of the array, which results in five zeros being printed. The memory is then freed using `free`.

77. What is the output of this code?


int *arr = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = i + 1;
}
free(arr);
arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = (i + 1) * 2;
}
for (int i = 0; i < 3; i++) {
    printf("%d ", arr[i]);
}
free(arr);

ⓐ. 1 2 3 4 5

ⓑ. 2 4 6

ⓓ. Causes a segmentation fault

Correct Answer: 2 4 6

Explanation: The code first allocates memory for 5 integers and initializes them. After freeing this memory, it allocates memory for 3 integers and initializes these new elements with values 2, 4, and 6. The code prints 2, 4, 6 and then frees the allocated memory.

78. What is the purpose of the following code?


int *ptr = (int*)malloc(5 * sizeof(int));
if (ptr != NULL) {
    for (int i = 0; i < 5; i++) {
        ptr[i] = i;
    }
    free(ptr);
}
ptr = (int*)calloc(5, sizeof(int));
if (ptr != NULL) {
    for (int i = 0; i < 5; i++) {
        printf("%d ", ptr[i]);
    }
    free(ptr);
}

ⓐ. Allocates memory for 5 integers and prints uninitialized values

ⓑ. Allocates memory for 5 integers, initializes with index values, frees, allocates again, and prints zeros

ⓓ. Allocates memory for 5 integers and prints garbage values

Correct Answer: Allocates memory for 5 integers, initializes with index values, frees, allocates again, and prints zeros

Explanation: The code allocates memory for 5 integers, initializes them with their index values, and frees the memory. It then allocates memory again using `calloc`, which initializes all elements to zero, and prints these values.

79. What will be the result of this code?


int *a = (int*)malloc(4 * sizeof(int));
for (int i = 0; i < 4; i++) {
    a[i] = i + 1;
}
int *b = (int*)malloc(4 * sizeof(int));
memcpy(b, a, 4 * sizeof(int));
for (int i = 0; i < 4; i++) {
    printf("%d ", b[i]);
}
free(a);
free(b);

ⓐ. 1 2 3 4

ⓑ. 1 2 3 4 5

ⓓ. Causes a segmentation fault

Correct Answer: 1 2 3 4

Explanation: The code allocates memory for two arrays of 4 integers each. It initializes the first array and copies its contents to the second array using `memcpy`. The code prints the elements of the second array, which are 1, 2, 3, and 4, and then frees both memory blocks.

80. What does the following code do?


char *str = (char*)malloc(5 * sizeof(char));
strcpy(str, "Test");
str = (char*)realloc(str, 10 * sizeof(char));
strcat(str, "ing");
printf("%s\n", str);
free(str);

ⓐ. Test

ⓑ. Testing

ⓓ. Undefined behavior

Correct Answer: Testing

Explanation: The code allocates memory for a string, copies "Test" into it, reallocates memory to expand the string, concatenates "ing" to the existing string, and prints "Testing". The memory is then freed.

81. What is the output of the following code?


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i * 2;
}
free(arr);
arr = (int*)calloc(3, sizeof(int));
for (int i = 0; i < 3; i++) {
    printf("%d ", arr[i]);
}
free(arr);

ⓐ. 0 0 0

ⓑ. 0 2 4

ⓒ. 2 4 6

ⓓ. Undefined behavior

Correct Answer: 0 0 0

Explanation: The code first allocates memory for 3 integers and initializes them to 0, 2, and 4. After freeing this memory, it allocates memory again using `calloc`, which initializes all elements to zero. The code prints three zeros.

82. What does the following code snippet print?


int *ptr = (int*)malloc(2 * sizeof(int));
ptr[0] = 5;
ptr[1] = 10;
ptr = (int*)realloc(ptr, 3 * sizeof(int));
ptr[2] = 15;
for (int i = 0; i < 3; i++) {
    printf("%d ", ptr[i]);
}
free(ptr);

ⓐ. 5 10 15

ⓑ. 5 10 0

ⓓ. 0 0 0

Correct Answer: 5 10 15

83. What is the effect of this code?


int *arr = (int*)malloc(4 * sizeof(int));
for (int i = 0; i < 4; i++) {
    arr[i] = i;
}
free(arr);
arr = (int*)malloc(4 * sizeof(int));
for (int i = 0; i < 4; i++) {
    printf("%d ", arr[i]);
}
free(arr);

ⓐ. Prints four uninitialized values

ⓑ. Prints four zeros

ⓓ. Prints 0 1 2 3

Correct Answer: Prints four uninitialized values

Explanation: After the first `malloc` and initialization, the memory is freed. The second `malloc` allocates new memory, which is uninitialized. The code prints the uninitialized values of the new memory block.

84. What will be the output of this code?


int *ptr = (int*)malloc(2 * sizeof(int));
ptr[0] = 1;
ptr[1] = 2;
free(ptr);
ptr = (int*)malloc(2 * sizeof(int));
ptr[0] = 3;
ptr[1] = 4;
printf("%d %d\n", ptr[0], ptr[1]);
free(ptr);

ⓐ. 1 2

ⓑ. 3 4

ⓒ. 0 0

ⓓ. Undefined behavior

Correct Answer: 3 4

Explanation: The code allocates memory for 2 integers, initializes them, and then frees this memory. It then allocates new memory for 2 integers again and initializes these new elements to 3 and 4. The code prints 3 and 4.

85. What is the purpose of this code snippet?


int *arr = (int*)calloc(3, sizeof(int));
for (int i = 0; i < 3; i++) {
    printf("%d ", arr[i]);
}
free(arr);

ⓐ. Allocates memory for 3 integers and leaves them uninitialized

ⓑ. Allocates memory for 3 integers, initializes them to zero, and prints them

ⓓ. Allocates memory for 3 integers and initializes them with index values

Correct Answer: Allocates memory for 3 integers, initializes them to zero, and prints them

Explanation: The `calloc` function allocates memory for 3 integers and initializes all elements to zero. The for loop prints each element of the array, which results in three zeros being printed. The memory is then freed using `free`.

86. What does the following code do?


int *a = (int*)malloc(3 * sizeof(int));
a[0] = 10;
a[1] = 20;
a[2] = 30;
int *b = (int*)malloc(3 * sizeof(int));
memcpy(b, a, 3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    printf("%d ", b[i]);
}
free(a);
free(b);

ⓐ. 10 20 30

ⓑ. 0 0 0

ⓓ. Undefined behavior

Correct Answer: 10 20 30

Explanation: The code allocates memory for two arrays of 3 integers each. It initializes the first array and copies its contents to the second array using `memcpy`. The code prints the elements of the second array, which are 10, 20, and 30, and then frees both memory blocks.

87. What is the output of this code?


int *arr = (int*)malloc(3 * sizeof(int));
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
free(arr);
arr = (int*)realloc(arr, 6 * sizeof(int));
for (int i = 0; i < 6; i++) {
    printf("%d ", arr[i]);
}
free(arr);

ⓐ. 1 2 3 0 0 0

ⓑ. 1 2 3 followed by garbage values

ⓓ. Undefined behavior

Correct Answer: Undefined behavior

Explanation: After `free(arr)`, the memory is deallocated, and accessing it (even with `realloc`) results in undefined behavior. The new allocation may or may not preserve the original values and will contain uninitialized values for the new elements.

88. What does the following code snippet print?


char *str;
str = (char*)malloc(6 * sizeof(char));
strcpy(str, "Hello");
free(str);
str = (char*)calloc(6, sizeof(char));
printf("%s\n", str);
free(str);

ⓐ. Hello

ⓑ. (empty string)

ⓓ. Undefined behavior

Correct Answer: (empty string)

Explanation: The code allocates memory for a string and copies "Hello" into it, then frees this memory. It then allocates new memory using `calloc`, which initializes all elements to zero. The `printf` statement prints an empty string as the new memory block is initialized to zero.

89. What will be the result of this code?


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i * 5;
}
free(arr);
arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    printf("%d ", arr[i]);
}
free(arr);

ⓐ. Prints three uninitialized values

ⓑ. Prints three zeros

ⓓ. Prints 0 5 10

Correct Answer: Prints three uninitialized values

90. What is the output of this code?


int *a = (int*)malloc(3 * sizeof(int));
a[0] = 1;
a[1] = 2;
a[2] = 3;
int *b = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    b[i] = a[i] * 2;
}
for (int i = 0; i < 3; i++) {
    printf("%d ", b[i]);
}
free(a);
free(b);

ⓐ. 2 4 6

ⓑ. 1 2 3

ⓓ. Undefined behavior

Correct Answer: 2 4 6

Explanation: The code allocates memory for two arrays of 3 integers each. It initializes the first array with values 1, 2, and 3. It then initializes the second array with values that are double the corresponding values of the first array. The code prints 2, 4, and 6 and then frees both memory blocks.

91. Which of the following code snippets correctly allocates memory for an array of 5 integers and initializes them to zero using `calloc`?

ⓐ.


int *arr = (int*)calloc(5, sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = 0;
}

ⓑ.


int *arr = (int*)calloc(5, sizeof(int));

ⓒ.


int *arr = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = 0;
}

ⓓ.


int *arr = (int*)malloc(5 * sizeof(int));

Correct Answer: .

Explanation: The `calloc` function automatically initializes all allocated memory to zero. Option B correctly uses `calloc` to allocate memory for 5 integers and initializes them to zero.

92. Which of the following code snippets correctly resizes a dynamically allocated array and initializes new elements to zero?

ⓐ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
arr = (int*)realloc(arr, 5 * sizeof(int));
for (int i = 3; i < 5; i++) {
    arr[i] = 0;
}

ⓑ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
arr = (int*)realloc(arr, 5 * sizeof(int));

ⓒ.


int *arr = (int*)realloc(NULL, 5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = 0;
}

ⓓ.


int *arr = (int*)calloc(5, sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}

Correct Answer: .

Explanation: Option A correctly resizes the array using `realloc` and then initializes the new elements to zero. `realloc` preserves the existing values and does not initialize the new elements, so they must be explicitly set to zero.

93. Which of the following code snippets correctly frees allocated memory and sets the pointer to NULL?

ⓐ.


int *arr = (int*)malloc(5 * sizeof(int));
free(arr);

ⓑ.


int *arr = (int*)malloc(5 * sizeof(int));
free(arr);
arr = NULL;

ⓒ.


int *arr = (int*)calloc(5, sizeof(int));
free(arr);
arr = NULL;

ⓓ.


int *arr = (int*)calloc(5, sizeof(int));
free(arr);

Correct Answer: .

Explanation: Option B correctly frees the allocated memory and then sets the pointer to NULL. This practice helps avoid dangling pointers, which can lead to undefined behavior if dereferenced.

94. Which of the following code snippets demonstrates a memory leak?

ⓐ.


int *arr = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = i;
}
free(arr);

ⓑ.


int *arr = (int*)calloc(5, sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = i;
}
free(arr);

ⓒ.


int *arr = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = i;
}
arr = (int*)malloc(10 * sizeof(int));

ⓓ.


int *arr = (int*)calloc(5, sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = i;
}

Correct Answer: .

Explanation: Option C demonstrates a memory leak because the original memory allocated for `arr` is not freed before reassigning `arr` to a new block of memory. This results in the original memory becoming inaccessible, leading to a memory leak.

95. Which of the following code snippets correctly copies contents from one dynamically allocated array to another?

ⓐ.


int *arr1 = (int*)malloc(5 * sizeof(int));
int *arr2 = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr1[i] = i;
}
memcpy(arr2, arr1, 5 * sizeof(int));

ⓑ.


int *arr1 = (int*)calloc(5, sizeof(int));
int *arr2 = (int*)calloc(5, sizeof(int));
for (int i = 0; i < 5; i++) {
    arr1[i] = i;
}
memcpy(arr2, arr1, 5 * sizeof(int));

ⓒ.


int *arr1 = (int*)malloc(5 * sizeof(int));
int *arr2 = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr1[i] = i;
}
arr2 = arr1;

ⓓ.


int *arr1 = (int*)calloc(5, sizeof(int));
int *arr2 = (int*)calloc(5, sizeof(int));
for (int i = 0; i < 5; i++) {
    arr1[i] = i;
}
arr2 = arr1;

Correct Answer: .

Explanation: Option A correctly uses `memcpy` to copy the contents from `arr1` to `arr2`. `memcpy` copies a specified number of bytes from the source to the destination, preserving the data.

96. Which of the following code snippets demonstrates correct use of `realloc` to double the size of an array?

ⓐ.


int *arr = (int*)malloc(3 * sizeof(int));
arr = (int*)realloc(arr, 6 * sizeof(int));

ⓑ.


int *arr = (int*)calloc(3, sizeof(int));
arr = (int*)realloc(arr, 6 * sizeof(int));

ⓒ.


int *arr = (int*)malloc(3 * sizeof(int));
free(arr);
arr = (int*)realloc(arr, 6 * sizeof(int));

ⓓ.


int *arr = (int*)calloc(3, sizeof(int));
free(arr);
arr = (int*)realloc(arr, 6 * sizeof(int));

Correct Answer: .

Explanation: Option A correctly uses `realloc` to resize the memory block to double its original size. The existing data is preserved, and the new elements remain uninitialized.

97. Which of the following code snippets demonstrates the correct way to initialize dynamically allocated memory using `malloc`?

ⓐ.


int *arr = (int*)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = 0;
}

ⓑ.


int *arr = (int*)malloc(5 * sizeof(int));

ⓒ.


int *arr = (int*)calloc(5, sizeof(int));

ⓓ.


int *arr = (int*)realloc(NULL, 5 * sizeof(int));
for (int i = 0; i < 5; i++) {
    arr[i] = 0;
}

Correct Answer: .

Explanation: Option A correctly allocates memory using `malloc` and then initializes each element to zero. `malloc` does not initialize the memory, so the elements must be explicitly set to zero.

98. Which of the following code snippets correctly resizes a dynamically allocated array without losing existing data?

ⓐ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
arr = (int*)realloc(arr, 5 * sizeof(int));

ⓑ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
arr = (int*)calloc(5, sizeof(int));

ⓒ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
arr = (int*)malloc(5 * sizeof(int));

ⓓ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
free(arr);
arr = (int*)malloc(5 * sizeof(int));

Correct Answer: .

Explanation: Option A correctly resizes the array using `realloc` without losing existing data. `realloc` preserves the existing elements and adds new uninitialized elements to the resized array.

99. Which of the following code snippets demonstrates correct use of `free` and avoids a dangling pointer?

ⓐ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
free(arr);
arr = NULL;

ⓑ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
free(arr);

ⓒ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}
free(&arr);

ⓓ.


int *arr = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++) {
    arr[i] = i;
}

Correct Answer: .

Explanation: Option A correctly frees the dynamically allocated memory using `free` and then sets the pointer to `NULL`. Setting the pointer to `NULL` after freeing helps avoid a dangling pointer, which can lead to undefined behavior if dereferenced.

100. Which of the following code snippets demonstrates the correct way to handle errors when allocating memory using `malloc`?

ⓐ.


int *arr = (int*)malloc(100000000000 * sizeof(int));
if (arr == NULL) {
    printf("Memory allocation failed.\n");
}

ⓑ.


int *arr = (int*)malloc(100000000000 * sizeof(int));

ⓒ.


int *arr = (int*)malloc(100000000000 * sizeof(int));
free(arr);

ⓓ.


int *arr = (int*)malloc(100000000000 * sizeof(int));
if (!arr) { 
    printf("Memory allocation failed.\n");
}

Correct Answer: .

Explanation: Option D demonstrates the correct way to check if memory allocation using `malloc` fails. If `malloc` returns `NULL`, it indicates that memory allocation failed, and appropriate error handling can be implemented.

Dynamic Memory Allocation MCQs – Part 1

Related MCQs