Initialization and updation of variable types

Question

I understand that static variables are initialized only once during the lifetime of the program (see here for reference). Also, Static variables maintain their value between function invocations. How then, are static variables modified?

For example how is "a" modified in the following piece of code:

#include <stdbool.h>

void foo(){
    static int a;
    printf("%d\n",a);
    a++;
    printf("%d\n",a);
}
int main()
{
foo();
foo();
return 0;
}

Contrariwise, how are non-static variables modified? more specifically, how is "a" modified in the following peice of code?

 #include <stdbool.h>

void foo(){
    int a = 2;
    printf("%d\n",a);
    a++;
    printf("%d\n",a);
}
int main()
{
foo();
foo();
return 0;
}

Answer 1

in your first example, the static variable has local scope, but has the same lifecycle as a global variable, and initialized once at program startup. You do that when you want to achieve a side effect (something is initialized, global function call counter...: calling the subroutine has an effect even if it returns nothing...)

It has the same address at every call (which means you could return its address and modify it from somewhere).

in your second example, you define an auto variable, allocated and initialized each time. It may have a different address depending on the call chain (in all calls, recursive, threaded, the variable is guaranteed to be unique, and not modifiable by other calls/threads: no edge effect, reetrant)

Won't make much difference on a main(), but if you put that in a subroutine, in the first case, 2 consecutive calls will yield a different result (2,3, then 3,4), whereas in the second case, 2 consecutive calls will yield the same result (2,3 twice)

Answer 2

A different example may make this a bit more clear.

Assume you have the following function:

void foo( void )
{
  int a = 1;
  printf( "&a = %p, a = %d\n", (void *) &a, a++ );
}

We create a variable a with an initial value of 1, print out its address and value, and then increment it. This variable is not visible outside the scope of the foo function.

The variable a has auto storage duration; its lifetime is limited to the lifetime of the foo function. A new instance of a will be created and initialized every time foo is entered, and that instance is destroyed every time foo exits¹.

Now we add the static keyword to the declaration:

void foo( void )
{
  static int a = 1;
  printf( "&a = %p, a = %d\n", (void *) &a, a++ );
}

a now has static storage duration; a single instance of a is created and initialized once at program startup, and that instance is maintained until the program exits. a is still only visible by name within the scope of foo, but its lifetime extends beyond the lifetime of the foo function.

In both cases, the value of a is updated in exactly the same way; we update the contents of the memory location that a corresponds to. The only difference is how the contents of that memory location are maintained over the lifetime of the program.

To drive this home, take the following code:

#include <stdio.h>

void foo( void )
{
  int a = 1;
  printf( "&a = %p, a = %d\n", (void *) &a, a );
  a++;
}

void bar( void )
{
  int b = 2;
  foo();
  printf( "&b = %p, b = %d\n", (void *) &b, b );
  b++;
}

void bletch( void )
{
  int c = 3;
  bar();
  printf( "&c = %p, c = %d\n", (void *) &c, c );
  c++;
}

int main( void )
{
  foo();
  bar();
  bletch();
  bar();
  foo();
  return 0;
}

All of a, b, and c are declared auto (which is the default). When I build and run this code, I get the following output:

&a = 0x7fff701d234c, a = 1
&a = 0x7fff701d232c, a = 1
&b = 0x7fff701d234c, b = 2
&a = 0x7fff701d230c, a = 1
&b = 0x7fff701d232c, b = 2
&c = 0x7fff701d234c, c = 3
&a = 0x7fff701d232c, a = 1
&b = 0x7fff701d234c, b = 2
&a = 0x7fff701d234c, a = 1

New instances of a, b, and c are created and initialized when their respective functions are entered and destroyed when the functions exit. They get different addresses depending on where the functions are in the call chain².

If I change that code such that a is declared

static int a = 1;

I get the following output:

&a = 0x500a58, a = 1
&a = 0x500a58, a = 2
&b = 0x7fffd1e75ccc, b = 2
&a = 0x500a58, a = 3
&b = 0x7fffd1e75cac, b = 2
&c = 0x7fffd1e75ccc, c = 3
&a = 0x500a58, a = 4
&b = 0x7fffd1e75ccc, b = 2
&a = 0x500a58, a = 5

So, a couple of things are immediately apparent - the address of a doesn't change with each call to foo, and the value of a is not re-initialized every call. Again, the instance for a is created and initialized once when the program starts up, and that instance persists beyond the lifetime of foo.

Declaring b as static gives us

&a = 0x500a58, a = 1
&a = 0x500a58, a = 2
&b = 0x500a5c, b = 2
&a = 0x500a58, a = 3
&b = 0x500a5c, b = 3
&c = 0x7fffc301f8cc, c = 3
&a = 0x500a58, a = 4
&b = 0x500a5c, b = 4
&a = 0x500a58, a = 5

Don't read too much into the address values themselves; that all depends on the platform. Obviously, on my platform, static items are stored in a very different location than auto items, but another platform might not show as obvious a difference.

---

1. In practice, the space for auto variables is taken from the runtime stack, although that's an implementation detail, not a language requirement.
2. Notice how the same addresses may be re-used for different objects depending on where the function is in the call chain.

Answer 3

How is the static variable updated?

I suspect you are getting confused by the fact that a variable declaration that includes an initializer is syntactically similar to an assignment expression. The fact that a variable with static duration (or any other variable) is initialized at most once does not have anything to do with how you can modify that variable later. It is a statement about program semantics, not a restriction on your code.

Alternatively, you are perhaps confused about the difference between "initialization" and "assignment". These have specific, different meanings in this context. This contains an initialization of variable a, but no assignment to it:

int main() {
   int a = 2;  /* initialization */
   printf("%d",a);
}

This contains an assignment to variable a, but no initialization of it:

int main() {
   int a;  /* no initialization */
   a = 2;  /* assignment */
   printf("%d",a);
}

This contains both an initialization of a and an assignment to it:

int main() {
   int a = 2;
   printf("%d",a);
   a = 3;
   printf("%d",a);
}

You can update a static variable via any operator suitable for its type that has a side effect of modifying its operand (=, +=, ++, etc.), or in any number of indirect ways via pointer. For most purposes, code using a variable does not need to pay any attention to its storage duration. In particular, the two examples above are equally valid and produce the same output if variable a is made static. Don't take that to mean that static variables are without characteristic uses, but "What are static variables useful for?" is an entirely separate question.

Answer 4

The question aims to draw out how static variables are modified, given the fact that static variables maintain their value between function invocations. I also wanted to know how the above would be different from the modification of any non-static variable.

As per the answers posted, it turns out that all variables are modified either directly (via operands) or indirectly (via pointers).

However, the answers posted emphasize the difference in storage duration of static and non-static variables.

Firstly, it is important that one understands the difference between Initialization, Declaration and Assignment, as pointed out (quite consicely) by John Bollinger's answer. The answer points out that none of the italicized operations performed on any kind of variable affect it's storage duration.

Next, it is important one understands that a static variable has the same life-cycle as that of a global variable (regardless of whether the static variable has a local or global scope). This is pointed out by Jean-Francois Fabre's answer. Additionally, one might rule out the play of linkage since, as pointed out in the comments by @Olaf, a local variable has no linkage, whilst a static variable might have internal,external or no linkage. However, a static variable inside a function has no linkage.

Finally, one must realize how static variables behave, as pointed out brilliantly by John Bode's Answer