CODEWITHSUNDEEP
cfunctionstatic
seereddi sekhar
seereddi sekhar

Reputation: 881

How the static variable gets retrieved for every function call

We know that when the control exits from function the stack space will be freed. So what happens for static variables. Will they be saved in any memory and retrieved when the function gets called ??

Upvotes: 3

Views: 935

Answers (5)

dear_tzvi
dear_tzvi

Reputation: 745

Adding some more information on top of previously given answers -

The memory for static objects is allocated at compile/link time. Their address is fixed by the linker based on the linker control file.

The linker file defines the physical memory layout (Flash/SRAM) and placement of the different program regions.

The static region is actually subdivided into two further sections, one for initial value, and the other for changes done in run time.

And finally, remember that if you will not specify otherwise, the value will be set to 0 during compilation.

Upvotes: 3

August Karlstrom
August Karlstrom

Reputation: 11377

Consider this example:

static int foo;

void f(void)
{
    static int bar;
}

The only difference between foo and bar is that foo has file scope whereas bar has function scope. Both variables exist during the whole lifetime of the program.

Upvotes: 0

kaspersky
kaspersky

Reputation: 4117

Yes, static variables persist between function calls. They reside in data section of the program, like global variables.

You can (and probably should) read more about general memory layout of C applications here.

Upvotes: 3

Rahul Tripathi
Rahul Tripathi

Reputation: 172628

The wiki says:

In the C programming language, static is used with global variables and functions to set their scope to the containing file. In local variables, static is used to store the variable in the statically allocated memory instead of the automatically allocated memory. While the language does not dictate the implementation of either type of memory, statically allocated memory is typically reserved in data segment of the program at compile time, while the automatically allocated memory is normally implemented as a transient call stack.

and

Static local variables: variables declared as static inside a function are statically allocated while having the same scope as automatic local variables. Hence whatever values the function puts into its static local variables during one call will still be present when the function is called again.

Upvotes: 3

Sergey Kalinichenko
Sergey Kalinichenko

Reputation: 727067

You made an incorrect assumption that static variables are placed on the stack* when the function that uses them is running, so they need to be saved and retrieved.

This is not how C does it: static variables are allocated in an entirely different memory segment outside of stack, so they do not get freed when the function ends the scope of its automatic variables.

Typically, static data segment is created and initialized once upon entering the program. After that the segment stays allocated for as long as your program is running. All your global variables, along with the static variables from all functions, are placed in this segment by the compiler. That is why entering or leaving functions has no effect on these variables.

* The official name for "stack" is "automatic storage area".

Upvotes: 1

Related Questions