In This Article
What is Static Memory Allocation?
With respect to computer memory, static memory allocation refers to the specific part of the main memory of the system that is reserved for an application or a program when it is loaded for the first time.
In other words, it signifies the space in the memory that is reserved for a particular program, only one program can use this space at a time, which can be allocated again only when the particular program or application is closed.
- Static memory allocation is done during compilation and before a program starts its execution process.
- It offers more efficiency and speed in operation because there is no overhead involved in this type of memory allocation operation.
- The required size of memory for a program must be known for allocating memory statically.
- It may lead to wastage of memory since the desired size is assumed and not precise.
- Once the allocation is done, the assigned memory space cannot be deallocated, resized or reused.
Understanding Static Memory Allocation
Also referred to as compile-time memory allocation, static memory allocation allows the program to use a fixed amount of memory.
From a technical point of view, it is the compiler that assigns the declared static variables. These variables are accessible if an ‘address of’ operator is allotted to a pointer variable.
While allocating a memory space to a program statically, a few specific steps are followed as under:
- At first, the volume of data needed to complete the entire operation is determined.
- Then after, the algorithm comes into play which assumes the size of the memory that may be required by the program for the assumed volume of data.
The final allocation of memory space is then made, and as you can see, it is done entirely on the basis of a couple of assumptions.
In such a situation, there can be two evident possibilities, such as:
- The allocated space may be insufficient for the program to operate. If that happens, then it will lead to inefficient processing of data.
- The size of the memory assigned may be larger than what is required by the application. In such a situation, the unused memory space will go to waste because it cannot be deallocated or reused.
Just as the name implies, the variables used in static memory allocation are also static, and these variables continue to exist until the completion of the program or application.
Typically, these static variables in this type of memory allocation are declared by using the keyword ‘static’ in commands such as:
- static int x;
- static float y;
The static variables can be either of the following:
However, which one it will be typically depends on the place of assertion.
Normally, each of these two types of variables has different features as explained hereunder:
Internal static variables
- The internal static variables refer to those variables that are declared within a function.
- These variables have their scope typically extended up to the termination of the function, and they are normally defined in it.
- These are pretty much the same as auto variables, but usually remain alive or in existence all through the rest of the part of the program.
External static variables
- The external static variables refer to those that are declared outside all functions.
- These variables are available to use for all the functions of the specific application or program.
Static Memory Allocation Example
One of the most significant examples of static memory allocation is the declaration of a program in an array or for a variable in the program.
Here the memory is assigned during the compile time and the address can be gotten with the help of an ‘&’ operator. It can also be assigned to a pointer.
When the ultimate size of the variable is ascertained even before the program is run by using a stack for maintaining the allocation and cannot be changed, it is supposed to be a static memory allocation.
It is also referred to as compile-time memory allocation.
- The allocation is typically done during the compilation time and before running the program.
- Stack memory is usually used in this process.
- During the execution of the program, the allocated memory cannot be changed or freed.
- The allocation process is usually used in an array and is simple and fast, but less efficient than dynamic memory allocation.
- Once the memory is allocated, it cannot be reused, resized, or deallocated.
- It is done when the size of the array is known.
- It allocates static or unchanging data.
- It allows changing the content of the static assembly without escalating the memory space assigned to it.
- It allows declaring global variables ahead of time.
- The runtime for it is the same as the runtime for the entire program.
- The execution time is more efficient and controlled in a better way.
- The representation of the program codes is more natural.
- Extra release operations are not needed with the delete operator.
- It ensures that there are lower numbers of errors in programming.
- Every new operator has its own individual delete statement.
- It follows a stack data structure.
- It may cause wastage of space if larger static data space is declared.
- The size cannot be changed during runtime even if less static space is declared than what is required.
- It needs to know the precise memory requirement of the specific program or application.
- It does not allow freeing the memory even if it is not utilized.
Why is Static Memory Allocation Fast?
The most significant factor that makes the static memory allocation much faster and more efficient is that memory is typically allocated to a process in this method even before it starts running.
This means that there is no overhead associated with the operations of memory allocation, even when the program is running, which eventually expedites the process significantly.
And, when you compare it with dynamic memory allocation, it is faster because the compiler needs to work one step less while hard-coding the variable data into it.
For example, it simply has to estimate the offset to a specific element of an array to be accessed from the static address delineated at compile time.
Typically, it does not have to read the variable data containing the pointer to the opening of the array.
Moreover, the space allocated to a program cannot be changed during operation which also helps it to operate faster.
Is Static Memory in Stack or Heap?
Typically, static memory allocation is related to stack memory and is smaller than heap memory. It is usually referred to as compile time allocation.
Heap memory, on the other hand, is typically related to dynamic memory allocation.
It is larger than stack memory and is usually referred to as runtime allocation.
Static memory allocation refers to the process of allocating memory space to a program during compilation based on an assumption of the amount of memory it will need during the entire operation.
It is better than dynamic memory allocation in quite a few respects, but it also comes with a fair share of limitations.