5

After stumbling onto this question and reading a little more here (c++ but this issue works the same in C/C++ AFAIN) I saw no mention to what is realy happening inside the function. 

void f(){
  static int c = 0;
  printf("%d\n",c++);
}

int main(){
  int  i = 10;
  while(i--)
    f();
  return 0;
}

In this snippet, c lifetime is the entire execution of the program, so the line static int c = 0; has no meaning in the next calls to f() since c is already a defined (static) variable, and the assignment part is also obsolete (in the next calls to f()), since it only takes place at the first time.

So, what does the compiler do? does it split f into 2 functions - f_init, f_the_real_thing where f_init initializes and f_the_real_thing prints, and calls 1 time f_init and from that onward, only calls f_the_real_thing?

CIsForCookies
  • 12,097
  • 11
  • 59
  • 124
  • 2
    *"In this snippet, c lifetime starts when f() is first called from main"* - [Not for a C static, no](http://port70.net/~nsz/c/c11/n1570.html#6.2.4p3). – StoryTeller - Unslander Monica Jul 25 '17 at 11:02
  • Simply treats the variable like one of a global scope, reserving initialized data in the `.data` section, while keeping the linkage static to the module. – Frankie_C Jul 25 '17 at 11:06
  • @StoryTeller I was mislead by the C++ answer. I'll edit, thanks – CIsForCookies Jul 25 '17 at 11:19
  • "(c++ but this issue works the same in C/C++ AFAIN)" That's not really true. First because there is no such thing as "C/C++". Second because in C++ cou can initialize a static variable with the return value of a function. In C this is not possible. Therefore please don't mix up languages. – Gerhardh Jul 25 '17 at 12:20
  • the program loader allocates the memory and initializes it. Thereafter, the execution of the program reads/writes the variable in memory. – user3629249 Jul 25 '17 at 22:40

3 Answers3

7

The first assignment is not "obsolete" - it ensures c is zero the first time f() is called. Admittedly that is the default for statics: if no initialiser is specified, it will be initialised to zero. But a static int c = 42 will ensure c has the value 42 the first time the function is called, and the sequence of values will continue from there.

The static keyword means that the variable has static storage duration. It is only initialised once (so will have that value the first time the function is called) but changes then persist - any time the value is retrieved, the value retrieved will be the last stored in the variable.

All the compiler does is place the variable c into an area of memory that will exist - and hold whatever value it was last set to - for as long as the program is running. The specifics of how that is achieved depends on the compiler.

However, I have never seen a compiler that splits the logic of the function into multiple parts to accommodate the static.

Peter
  • 35,646
  • 4
  • 32
  • 74
  • " Admittedly that is the default for statics: if no initialiser is specified, it will be initialised to zero". Plus one for especially that. – Bathsheba Jul 25 '17 at 11:15
  • I didn't mean the assignment is obsolete entirely - only _after_ the first call to f, but I guess I could have said that in a more coherent way – CIsForCookies Jul 25 '17 at 11:23
6

Although the standard does not dictate how compilers must implement behavior, most compilers do a much less sophisticated thing: they place c into static memory segment, and tell the loader to place zero into c's address. This way f comes straight to pre-initialized c, and proceeds to printing and incrementing as if the declaration line where not there.

In C++ it optionally adds code to initialize c to static initialization function, which initializes all static variables. In this case, no call is required.

In essence, this amounts to c starting its lifetime before the first call to f. You can think of c's behavior as if it were a static variable outside f() with its visibility constrained to f()'s scope.

Sergey Kalinichenko
  • 714,442
  • 84
  • 1,110
  • 1,523
  • Note that the C++ case would be different for objects with dynamic initialization – M.M Jul 25 '17 at 11:13
4

The C standard doesn't specify how the required behaviour for static storage duration must be implemented.

If you're curious about how your particular implementation handles this, then you can always check the generated assembly.

(Note that in your particular case, your code is vulnerable to concurrency issues centred around c++ not necessarily being atomic; also its vulnerability to int overflow, although i-- does act as an adequate termination condition.)

Bathsheba
  • 231,907
  • 34
  • 361
  • 483