37

I don't understand what the following code example does and how it does it:

#include <stdio.h>

int f();

int a = f(); // a exists just to call f

int x = 22;

int f() {
    ++x;
    return 123; // unimportant arbitrary number
}

int main() {
    printf("%d\n", x);
}

When this is ran it prints 23, which is the intuitive answer.

However in C++, global variables are supposed to be initialized in order of definition. That would mean that a should be initialized before x, because it is defined before x. If that was the case, then the function f would have to be called before x was initialized, because the call to f is a part of a's definition.

If f is indeed called before x is initialized, that would mean that f would try to increment x -- the result of which I'm not really certain of (most likely UB, or some gibberish value). Then, after a is initialized, x would be initialized to 22 and the program would print out 22.

Evidently that's not what happens. But what does? What does that code actually do?

It definitely seems like x is set to 22 before a = f() is evaluated, but that would mean that the order of initialization is reversed (I could also be wrong about what initialization is, or when it happens).

Community
  • 1
  • 1
corazza
  • 31,222
  • 37
  • 115
  • 186

2 Answers2

39

The issue is a little bit subtle; please refer to C++11 3.6.2 for details.

What matters for us is that there are two phases of initialization of "non-local variables with static storage duration" (or "global variables" in colloquial parlance): the static initialization phase and the dynamic initialization phase. The static phase comes first. It looks like this:

int a = 0;
int x = 22;

The dynamic initialization runs afterwards:

a = f();

The point is that static initialization doesn't "run" at all - it only consists of setting values that are known at compile time, so those values are already set before any execution happens. What makes the initialization int x = 22; static is that the initializer is a constant expression.

There are cases where dynamic initialization may be hoisted to the static phase (but does not have to), but this is not one of those cases, because it does not meet the requirement that

the dynamic version of the initialization does not change the value of any other object of namespace scope prior to its initialization

When this hoisting happens, it is permissible that the resulting initial values can be different from if it didn't happen. There's an example in the standard for one such "indeterminate" initialization.

Kerrek SB
  • 464,522
  • 92
  • 875
  • 1,084
  • So essentially, the initialization is separated into the non-side-effecting part that "runs" first (no functions, just assembly code that alters the memory and increments the stack pointer), and a side-effecting part that runs second (in which actual functions are executed). And if a function can be proven to have no side effects, then it can be hoisted into the first part. Do I understand it correctly? It make sense. Also, you wrote `x = f();`, but I think you meant `a = f();` (that's what's in my code). – corazza Mar 01 '14 at 17:22
  • Also the first sentence of your last paragraph is a little weird: *When this hoisting happens, it is permissible that the resulting initial values can be different from if it didn't happen.* - what do you mean? It kind of looks that you missed an "it", but in general what you're describing is a bit confusing, maybe posting that example would help? – corazza Mar 01 '14 at 17:29
  • 1
    @yannbane: The example is in the section I cited. I'm reluctant to start copying large parts of it, because you should essentially read all of it. I recommend you [head over to github](https://github.com/cplusplus/draft) and grab yourself a copy of the standard. Yes, there are two phases. The first phase doesn't even "alter memory" - the initial values are just written into the binary file and loaded into memory by the loader. – Kerrek SB Mar 01 '14 at 18:01
  • 1
    @yannbane: I pasted the example [on pastebin, here](http://pastebin.com/Ja1cXYe7). – Kerrek SB Mar 01 '14 at 18:03
  • 1
    @yannbane: I fixed the typo, sorry about that. – Kerrek SB Mar 01 '14 at 21:37
4

Also, consider:

#include <iostream>
using namespace std;

int f();
int g();

int a = f();
int b = g();

int main() {
        cout << a << " " << b;
}

int f() {
        b++;
        cout << "f" << endl;
        return 1;
}

int g() {
        cout << "g" << endl;
        return 2;
}

The output is:

f
g
1 2

Replacing b = g(); with b = 22; causes 1 23 to be printed. Kerrek SB's answer explains why this is.

OSborn
  • 895
  • 4
  • 10