Using constructor initializer list to initize Reference Variable

Question

I am trying to understand how classes are compiled in C++. And so creating different examples to understand initialization rules (along with theory from books). My example code is as follows:

#include <iostream>
using namespace std;

class NAME {
public:
    NAME(int p) : x(r) {
        cout << x << endl;
    }
    int &x;
    int r=3;  
};

int main() {
    NAME obj(4);
    return 0;
}

My question is that does the order in which I have specified the data members &x and int r=3 matter? I have checked by reversing the order of those two and still the program works. I have read that compilation of classes happens in two steps:

1. All member declarations are compiled.
2. Then function bodies are complied.

Now my question is according to this rule the declarations of reference type x should happened first (since compilation happens in order of variable declaration/definition) and then int type r should happen. And then constructor bodies should be compiled. But since we must always initialize a reference type, how is this program working when we have not initialized x? Also, I know that constructor initializer list are used to initialize x from r. I think I am getting confused about the fact that when using the initializer list, will the in-class declaration happen first or will the constructor list directly initialize the members? If it is the latter then why does the order of arguments in the initializer list matter?

PS: I know we have initialized x through the initializer list x(r) but what happens to the in-class definitions/declarations of x and r? Will they be ignored when a initializer list is present? And in what order does all this happens?

Answer 1

The example code is valid, though the pattern is a bit dangerous, and similar code could have Undefined Behavior.

It's not exactly accurate that class member declarations then definitions are compiled, or at least not in the sense you're interpreting it. It's true that function bodies and object member initializers inside a class declaration can use names of other members of the same class, even if they were not yet declared. But this rule only affects name lookup, and none of the rules about object lifetime or initialization. Exactly how and when a compiler does all this, we don't usually need to worry about for understanding what code will do.

Related terminology corrections to your one paragraph:

the declarations initialization of reference type x should happened first (since compilation initialization happens in order of variable declaration/definition) and then int type r should happen. And then constructor bodies should be compiled executed.

This does lead to situations, as in your example, where a member could be used before it is initialized, so the member's "lifetime" has not yet started. In the example, obj.x is initialized before obj.r. This situation needs to be handled with care, since most operations on an object outside its lifetime are undefined behavior. (For details, see Standard paragraph [basic.life]/7.) But just binding a reference to such an object is permitted. Of course, then most operations using that reference are also undefined behavior until the referenced object actually is initialized.

when we use initializer list then will the in-class declaration will happen first or the constructor list will directly initialize the members?

Whenever object initialization uses a constructor with a mem-initializer-list which specifies how to initialize a given member, any in-class initializer on that same member is entirely ignored. So the =3 on the declaration of member r does nothing in your example. It would still be possible for other constructors to omit initialization of r, and they would use the =3. If you added a default constructor NAME() = default;, this would also use it, since the default constructor's defaulted definition is like not using a mem-initializer-list at all.