Thread: Static variable initialization

Is this comment correct based on the code below: I was confused why var did not increment in each loop and why static_var did.

Is this correct: In the context [in function] var = 5 and is incremented by 1, var = 6. Then for each loop var is re-initialized var = 5. While the static_var (since it is initialized only once) retains its incremented value during the loop process. static_var = 5, ++, loop, static_var = 6 ++, loop......

Code:

include <stdio.h>
 
void function () { //An example function, with its own context
  int var = 5;
  Static int static_var = 5; // Static variable initialization
 
  printf("\t[in function] var = %d\n", var);
  printf("\t[in function] static var = %d\n", static_var);
  var++;                //increment var by 1
  static_var++;         //increment static_var by 1.
}
 
int main() {
  int i;
  static int static_var = 1337; //the main function, with its own context.
 
  for(i=0; i < 5; i++) {        //loop 5 times.
    printf("[in main] static_var = %d\n", static_var);
    function(); // Call the function
  }
}

[in main] static_var = 1337
[in function] var = 5
[in function] static var = 5
[in main] static_var = 1337
[in function] var = 5
[in function] static var = 6
[in main] static_var = 1337
[in function] var = 5
[in function] static var = 7
[in main] static_var = 1337
[in function] var = 5
[in function] static var = 8
[in main] static_var = 1337
[in function] var = 5
[in function] static var = 9

Originally Posted by sjmp

Then for each loop var is re-initialized var = 5.

That is not correct. The function var is recreated each time the containing function is called, and ceases to exist when the function returns. Each time the function is called it has a different variable named var that is initialised to the value of 5. It is not the same variable every time, getting reinitialised.

Originally Posted by sjmp

Then for each loop var is re-initialized var = 5.

Correct, but if a static variable is not specifically initialized, it's initialized to zero just one time.

Code:

#include <stdio.h>

void foo(void);

int main (void)
{
int i;

    for(i = 0; i < 10; i++)
        foo();
    return 0;
}

void foo(void)
{
static int j;

    printf("j = %d\n", j);
    j++;
}

output:

j = 0
j = 1
j = 2
j = 3
j = 4
j = 5
j = 6
j = 7
j = 8
j = 9

A static variable is only allocated once when the program begins and deallocated when the program ends. Essentially, a static variable is a global variable with local scope (scope is source file or function), and not stored on the stack.

Static (C++)

Grumpy - I appreciate the clarification. Do you know why every instance of the static variable var (in this instance) is assigned the same memory address? I do not understand how memory is allocated/distributed by the machine. Could be as simple as it was the last available address to assign, and then the first one available after the function returns.

[in main] static_var @ 0x601040 = 1337
[in function] var @ 0x7ffffdb024bc = 5
[in function] static_var @ 0x601044 = 5
[in main] static_var @ 0x601040 = 1337
[in function] var @ 0x7ffffdb024bc = 5
[in function] static_var @ 0x601044 = 6
[in main] static_var @ 0x601040 = 1337
[in function] var @ 0x7ffffdb024bc = 5
[in function] static_var @ 0x601044 = 7
[in main] static_var @ 0x601040 = 1337
[in function] var @ 0x7ffffdb024bc = 5
[in function] static_var @ 0x601044 = 8
[in main] static_var @ 0x601040 = 1337
[in function] var @ 0x7ffffdb024bc = 5
[in function] static_var @ 0x601044 = 9

Thanks

Originally Posted by sjmp

Grumpy - I appreciate the clarification. Do you know why every instance of the static variable var (in this instance) is assigned the same memory address? I do not understand how memory is allocated/distributed by the machine.

There is only one instance of the static variable static_var (in the function scope; there is a second static_var in the main scope which is a different variable with the same name).

If you're asking why each of the 5 instances of var (which is not static) get the same address, that's not guaranteed to happen, however in this specific case it's very likely. Most compilers choose to use a call stack for local variables, function parameters, etc. In this particular case, the stack is in the same state before each of the successive calls to function(), and so function's stack frame gets created at the same location over and over. If the stack were in a different state (say, by calling a different function that ultimately called into this function) then the local var would most likely get a different address because the stack frame would be created at a different location in memory.

All of that, by the way, is implementation defined. We talk about stack and heap but the standard doesn't guarantee there IS such a construct; however, it's very common that there is. Nothing about the C standard guarantees that var gets the same address every time through the loop (so you should absolutely never rely on that happening), but with how most implementations work, it's highly likely.