Difference between Static allocation and Stack allocation in C

In this article we will discuss the difference between Static allocation and Stack allocation in C but before discussing that difference we should know Static and Stack allocation in C

Static Allocation:

In C, "static allocation" describes the method of allocating memory for variables during compilation, and that memory stays constant for the duration of the program's execution. Static allocation is usually applied to variables whose values must hold throughout function calls and whose size and memory requirements are known at build time.

Memory Allocation:

It takes place during program startup and lasts till the program is terminated.

Storage Duration:

Static variables last the full runtime of the program.

Initialization:

Before a program runs, static variables are usually initialized just once.

Scope:

They may have a file-based or function-based scope. File scope permits access throughout the file, while function scope limits access to the function.

Lifetime:

Values hold for all function calls, which ensure the consistency of data.

Thread Safety:

By default, thread variables are not safe. Safe concurrent access requires thread synchronization techniques.

Usage:

This variable is frequently used for global configuration settings or counters that need to maintain their values between function calls.

Example:

Let us take an example to illustrate the Static Allocation in C.

 
#include<stdio.h>
// Static variable declaration and initialization
static int static_var = 0;
// Function to increment a static variable and print its value
void static_allocation() {
    static_var++;
    printf("Static variable value: %d\n", static_var);
}
// Function to demonstrate static allocation
int main() {
    printf("Static allocation:\n");  
    // Calling function to demonstrate static allocation
    static_allocation();
    static_allocation();
    static_allocation();
    return 0;
}

Output:

Stack Allocation:

In C, stack allocation refers to the runtime memory reservation for variables located within the function call stack. Variables that are declared inside the function are statically allocated by default and it will automatically get deallocated when the function is terminated. The stack variable's lifetime is only until the function call is active.

Memory Allocation:

The runtime environment of the program will control the allocation and deallocation of the stack variables and functions.

Storage Duration:

They are generated and destroyed by function calls, have a local scope, and live only within the function in which they are declared.

Initialization:

Stack variables allow for flexibility in the assignment of initial values because they can be initialized either at the time of declaration or later in the function.

Scope:

Ensuring encapsulation and data privacy, restricted to the function they are stated in.

Lifespan:

Stack variables are automatically deallocated at the function's exit and have a lifespan linked to the length of the function call.

Thread Safety:

Stack variables are fundamentally thread-safe because every thread normally has its call stack. Shared pointers to stack-allocated memory between threads must be used with caution, though.

Usage:

Function parameters, local variables inside functions, and temporary variables are frequently allocated using stack space. In function contexts, it works well for handling transient data management.

Example:

Let us take an example to illustrate the Stack Allocation in C.

 
#include<stdio.h>
// Function to demonstrate stack allocation
void stack_allocation(int n) {
    // Stack array declaration and initialization
    int stack_array[n];
    // Filling the stack array with values
    for(int i=0;i<n;i++){
        stack_array[i] = i + 1;
    }
    // Printing the stack array values
    printf("Stack array values:\n");
    for(int i=0;i<n;i++){
        printf("%d ", stack_array[i]);
    }
    printf("\n");
}
// Main function
int main() {
    int size1, size2;
    // Getting user input for the size of the first stack array
    printf("Enter the size of first stack1: ");
    scanf("%d", &size1);
    printf("Stack allocation for size %d:\n", size1);
    stack_allocation(size1);   
    // Getting user input for the size of the second stack array
    printf("Size of the array 1: ");
    scanf("%d", &size2);
    printf("Stack allocation for size %d:\n", size2);
    stack_allocation(size2);
    return 0;
}

Output:

Key differences between Static Allocation and Stack Allocation:

There are several main differences between the static allocation and stack allocation in C. Some main differences between these allocations are as follows:

Features	Static Allocation	Stack Allocation
Memory Allocation	Compile time allocation of memory.	Runtime allocation of memory.
Lifetime	Throughout the entire program.	Limited to the specific functions.
Initialization	Initialization is done before the program starts execution.	Initialization is done every time the function is called
Access Speed	Slower access compared to stack.	Faster access speed compared to static allocation.
Size	Limited for the system memory space.	Limited by the size of the stack.
Scope	Entire file scope or function scope.	Limited to the function scope.
Memory location	Location is fixed at compile time.	Dynamic memory allocation on the function call stack.
Usage	Useful for the variables with temporary values.	Useful for temporary variables.

Conclusion:

In conclusion, two memory management strategies in C have different properties: static allocation and stack allocation. Static allocation is used for variables that need long-term storage, and it is done at compile time, offering consistent memory allocation during program execution. On the other hand, stack allocation is another memory management technique that manages temporary data within functions by allocating and dealing with memory dynamically.

Next TopicC Programming Test

← prev next →