What are the differences between the stack and heap memory segments in C?

In C programming, the memory of a program is divided into different segments, including the stack and heap. The main differences between these two segments are:

Allocation and deallocation: Memory allocated on the stack is automatically allocated and deallocated by the program, while memory allocated on the heap is manually allocated and deallocated by the programmer.

Size: The stack is typically smaller in size than the heap, as it has a fixed size that is determined at compile-time. The heap, on the other hand, can grow or shrink dynamically during program execution.

Access speed: Access to memory on the stack is typically faster than access to memory on the heap, as it is managed by the program’s call stack and is therefore more efficient. Access to memory on the heap requires additional overhead, such as pointer dereferencing and memory allocation/deallocation.

Lifetime: Memory on the stack has a shorter lifetime than memory on the heap, as it is deallocated automatically when the function that created it returns. Memory on the heap, on the other hand, can persist beyond the lifetime of the function that created it.

Here is an example that demonstrates the use of stack and heap memory in C:

    #include <stdio.h>
    #include <stdlib.h>
    
    void stack_example() {
        int x = 10; // allocated on the stack
        printf("Value of x on stack: %dn", x);
    }
    
    void heap_example() {
        int* ptr = (int*) malloc(sizeof(int)); // allocated on the heap
        *ptr = 20;
        printf("Value of x on heap: %dn", *ptr);
        free(ptr); // deallocate memory on the heap
    }
    
    int main() {
        stack_example();
        heap_example();
        return 0;
    }

In this example, the stack_example() function allocates an integer variable x on the stack, while the heap_example() function allocates an integer variable ptr on the heap using the malloc() function. The value of x is printed to the console using the printf() function, and the memory allocated on the heap is deallocated using the free() function.

Overall, understanding the differences between the stack and heap memory segments in C is important for efficient and effective memory management in C programs.