Top C Programming Interview Questions (2025)

Question: How does memory management work in C?

Answer:

Memory management in C is a critical aspect of programming and involves the allocation, usage, and deallocation of memory during program execution. C provides developers with a fine-grained control over memory, unlike higher-level languages that manage memory automatically (e.g., garbage collection in languages like Java or Python). Understanding how memory management works in C is essential for writing efficient and error-free programs.

Memory management in C can be broken down into several key concepts and operations:

1. Memory Segments in C:

When a C program runs, the operating system allocates a specific area of memory for it. This memory is typically divided into several segments:

• Text Segment: This section stores the actual code of the program. It is often marked as read-only to prevent modification.
• Data Segment: This segment contains global and static variables that are initialized. It is divided into:
  • Initialized Data Segment: Stores global and static variables that are initialized by the programmer.
  • Uninitialized Data Segment (BSS): Stores global and static variables that are not initialized. These variables are set to zero by default when the program starts.
• Heap: This area is used for dynamic memory allocation (managed manually by the programmer). It grows towards the higher memory addresses.
• Stack: This section holds local variables and function call information (such as return addresses). It grows towards the lower memory addresses.
• Memory Mapped Segment: This area contains memory mappings of shared libraries or files.

2. Static and Automatic Memory Allocation:

• Static Memory Allocation:

  • Memory is allocated at compile-time. This is done for global variables, static variables, and constants.
  • The size of the memory is fixed at the time of compilation and cannot be changed at runtime.

  Example:

  int x = 10; // 'x' is stored in the data segment
  static int y = 20; // 'y' is stored in the data segment but has a static lifetime

• Automatic Memory Allocation:

  • Memory is allocated at runtime when a function is called for local variables.
  • When the function finishes executing, the memory is automatically freed when the function’s stack frame is destroyed.

  Example:

  void foo() {
      int z = 30; // 'z' is a local variable stored on the stack
  }

3. Dynamic Memory Allocation:

Dynamic memory allocation allows programs to request memory at runtime, based on the program’s needs. This memory is allocated from the heap, which is managed manually by the programmer.

C provides several functions for dynamic memory allocation:

a. malloc() (Memory Allocation):

malloc() allocates a specified number of bytes of memory and returns a pointer to the beginning of the allocated block. If memory cannot be allocated, it returns NULL.

int *ptr = (int *)malloc(sizeof(int) * 10); // Allocates space for an array of 10 integers
if (ptr == NULL) {
    printf("Memory allocation failed\n");
}

• malloc() does not initialize the allocated memory. The values in the allocated memory are undefined (could be garbage values).

b. calloc() (Contiguous Allocation):

calloc() allocates memory for an array of elements and initializes all the bytes to zero. It is often used when you want to allocate memory for an array of structures or integers and initialize all elements to zero.

int *ptr = (int *)calloc(10, sizeof(int)); // Allocates space for 10 integers and initializes them to 0
if (ptr == NULL) {
    printf("Memory allocation failed\n");
}

c. realloc() (Reallocation):

realloc() is used to resize a previously allocated memory block. It adjusts the size of the memory block, either increasing or decreasing the allocated memory. If it is increasing the size, it may move the block to a new location. It returns a pointer to the new block of memory (or NULL if the reallocation fails).

ptr = (int *)realloc(ptr, sizeof(int) * 20); // Resize the allocated memory to hold 20 integers
if (ptr == NULL) {
    printf("Reallocation failed\n");
}

d. free() (Memory Deallocation):

Once memory has been allocated dynamically using malloc(), calloc(), or realloc(), it must be explicitly freed to avoid memory leaks. The free() function releases the memory back to the system.

free(ptr); // Deallocates the memory pointed to by ptr
ptr = NULL; // Set the pointer to NULL to avoid dangling pointer issues

4. Memory Leaks and Dangling Pointers:

• Memory Leak: If memory is allocated dynamically but never freed, it results in a memory leak, causing the program to use up more memory over time, which can eventually crash the system.
• Dangling Pointer: After freeing a pointer, if the pointer is still used to access memory, it results in a dangling pointer, which can lead to undefined behavior. To avoid this, it is common to set the pointer to NULL after calling free().

5. Stack vs. Heap:

• Stack: Used for storing local variables and function call information. The memory is automatically managed, and the memory is freed when the function scope ends. The stack is generally faster but has limited size, making it unsuitable for large allocations.
• Heap: Used for dynamic memory allocation. Memory is manually allocated and deallocated. The heap has a larger size compared to the stack, but it is slower and more prone to fragmentation.

6. Example of Dynamic Memory Allocation and Deallocation:

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

int main() {
    int *arr;
    
    // Allocate memory for 5 integers
    arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1; // Exit if memory allocation fails
    }
    
    // Use the dynamically allocated memory
    for (int i = 0; i < 5; i++) {
        arr[i] = i * i;
    }
    
    // Print the values
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // Deallocate memory
    free(arr);
    return 0;
}

Output:

0 1 4 9 16

7. Best Practices for Memory Management in C:

• Always check if malloc(), calloc(), or realloc() returns NULL to ensure that memory allocation was successful.
• After using free(), set the pointer to NULL to avoid accessing memory that has been deallocated (dangling pointer).
• Keep track of all dynamically allocated memory and ensure it is freed once it is no longer needed to prevent memory leaks.
• Avoid using the memory after calling free() (dangling pointers).
• Minimize the use of the stack for large arrays or structures to avoid stack overflow.

Summary:

• Static memory allocation in C occurs at compile time (e.g., global and static variables).
• Automatic memory allocation occurs at runtime within function scopes, with memory automatically freed when the function scope ends.
• Dynamic memory allocation occurs at runtime using malloc(), calloc(), realloc(), and free(). These functions allow flexible memory management by allocating memory on the heap.
• Proper memory management involves carefully allocating and deallocating memory and avoiding issues like memory leaks and dangling pointers.

Understanding and properly managing memory in C is crucial for developing efficient and bug-free applications, as improper memory management can lead to errors, crashes, and performance degradation.

Question: What is the difference between ++i and i++?

Answer:

The difference between ++i (pre-increment) and i++ (post-increment) lies in the timing of the increment operation and the value that is returned in an expression. Both operators increment the value of i by 1, but they do so at different times and return different results.

1. Pre-Increment (++i):

The pre-increment operator first increments the value of i, and then returns the new value.

• Action: i is incremented before it is used in the expression.
• Result: The new value of i is returned.

Example:

int i = 5;
int result = ++i;  // Pre-increment
printf("i = %d, result = %d\n", i, result);

Explanation:

• The value of i is first incremented to 6.
• The new value of i (which is 6) is assigned to result.

Output:

i = 6, result = 6

2. Post-Increment (i++):

The post-increment operator first returns the current value of i, and then increments i.

• Action: The current value of i is used before it is incremented.
• Result: The original value of i (before the increment) is returned.

Example:

int i = 5;
int result = i++;  // Post-increment
printf("i = %d, result = %d\n", i, result);

Explanation:

• The original value of i (which is 5) is assigned to result before i is incremented.
• The value of i is incremented to 6 after the assignment.

Output:

i = 6, result = 5

Key Differences:

Operator	Action	Returned Value
++i (Pre-increment)	Increment i first, then return the new value.	The new value of i.
i++ (Post-increment)	Return the current value of i, then increment i.	The original value of i before increment.

3. Performance Considerations:

In terms of performance, the difference between ++i and i++ is negligible for primitive data types like int, char, etc., because modern compilers optimize the code efficiently.

However, for complex data types like iterators in C++ (or custom objects with overloaded increment operators), there may be slight performance differences due to the need for copying or returning values, but this is rarely a concern unless performance is critical.

Conclusion:

• Use ++i when you want to increment first and return the new value.
• Use i++ when you want to return the original value first and increment the variable afterward.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as C interview questions, C interview experiences, and details about various C job positions. Click here to check it out.