Are variables considered defined while calculation of their initialization value?

Question

This is my small program:

enum Type
{
    b = 1,
    c = 2
};

int main()
{
    Type b = b;
    std::cout << b << std::endl;

    return 0;
}

Which outputs 0. Can I conclude that the above definition consists of this sequential steps?

1. Declaration of b as variable of type Type
2. Definition of that variable and initialization with 0 default value
3. Evaluation of it's new value, which includes the variable itself (with value 0)
4. Assigning that new value to variable.

And, do variables get initialized with 0 always, even if they are explicitly initialized?

My second question is - if it uses the variable in it's initialization list in specified example, why then I don't get error about ambiguity? Is compiler trying to find b in the variable list first, and only then checks for declared enumeration?

Answer 1

Step 1 is correct, but the rest is wrong. What happens is that the variable b is defined and immediately initialized to the value of the variable b. This leads to undefined behavior because b is not initialized before it's used in its own initialization.

If you want to initialize it to Type::b then you need to explicitly write that:

Type b = Type::b;

Answer 2

Although the variable is considered defined during its own initialization, it is still illegal to evaluate it unit its initialization is complete. That is why Type b = b is undefined behavior.

The reason why the variable is even defined is so that you could do this:

struct X {
    int *p;
    int a;
};
X x = {&x.a, 123};
cout << *x.p << endl;

Using the variable being initialized for purposes other than its own evaluation is legal. In the example above, the initializer of x must be able to refer to x in order to compute the address of its a member. This is legal, because a itself is not evaluated (demo).