Many people have taught about the rules to C++’s initializers list and when they are used, but few have developed a model\/idea to explain why things are the way they are, such as why initializers list always follows the order which the members are declared, not the order declared by the users. <\/p>\n\n\n\n
There are just too many rules to remember, but there’s one easy explanation that you can quickly derive the behavior of initializer and use cases for initializer lists: if you were the compiler, how would you break classes into loose functions and variables (C++ without classes) which eventually what low level implementation (or assembly) sees: code and data?<\/p>\n\n\n\n
In C++, you can think of classes = structs + other features recognized by the compiler. This means fundamentally when a struct exist, (non-heap) memory is already allocated for all its members (heap memory are referenced by pointer, so it’s just an integer data member of the class). <\/p>\n\n\n\n
C++ is not Python where you can make up class members as you go (including inside the This is what roughly goes on when you create\/build an object in C++<\/p>\n\n\n\n So if I had to make my own initializer list processor in a pinch, I’d just write a macro preprocessor which translates parses the list bock { In C++ (also C if the concept came from there), there are a few constructs that doesn’t allow you to modify variables once it’s established. Therefore you need to intercept the process of “establishing the memory for data members of the struct”, aka the variable declaration block, modified by the initializer list syntax.<\/p>\n\n\n\n Say you have a class A declared like this:<\/p>\n\n\n\n Without initializer list, what this is doing is conceptually equivalent to mangling (adding prefix to the variable names) scoped (namespaced) global variables with an instance prefix (say ‘a_’)<\/p>\n\n\n\n I intentionally use placeholders Type1 and Type2 here because you’ll realize there are a few types in C++ that cannot be declared without providing an initial value:<\/p>\n\n\n\n Inintializer list gives you direct access to the variable declaration process before getting to the constructor where the declaration is already set and done, effectively doing this<\/p>\n\n\n\n If you visualize initializer lists as it simply unrolls as scoped namespace declaration in the open space, it’s immediately obvious why the language compiler is anal about the construction order which also dictates the dependency on previous members<\/p>\n\n\n\n This is the same as with inheritance, with B as the base (parent) class:<\/p>\n\n\n\n It’s obvious B (the base\/parent) must be established first before the child exist, but this is also the case when we translate initializer lists to open function declaration.<\/p>\n\n\n\n It’s also obvious from the open function declaration view that if you can put the values you want in the function declaration (initializer lists), doing so saves you an extra step modifying established values, so obviously it has better performance and less stuff to debug.<\/p>\n\n\n\n The other case is when your member objects had no default constructor (not even the implict one, which happens when you declare a multivariate constructor yet didn’t declare a constructor with zero input arguments). I’ll skip A’s constructor for now<\/p>\n\n\n\n Since there is no zero-argument (default) constructor for The only way to establish B is to explicitly call the 2-argument constructor And b must be built in the order A was declared, which is x first, then b (an instance of class B), then the constructor for A can start.<\/p>\n\n\n\n The situation is exactly the same as the case when class B is the parent\/base, which is the same as the declaration of B being moved to the first line (since parents needs to be established first before child exists). Unlike consts\/references that the initial value needs to be at the declaration because it’s later unmodifiable, lacking default\/zero-arg constructor means the default attempt to use them at declaration (unless otherwise specified, aka by initializer lists) will fail. <\/p>\n\n\n\n__init__<\/code> constructor) at runtime. This means by the time you get into a C++ constructor, ALL data members are already set up (just like variable declarations in loose\/outside-class code) and you are merely calling a function (constructor is automatically called first) to modify the already established variables (data members).<\/p>\n\n\n\n{\n BLOCK declaring virtual base classes \n (virtual inheritance blesses all methods with \n virtuals which means adding an extra vptr to \n the vtable to the object)\n\n virtual inheritance makes sure the grandparent\n is constructed by the child first to be SHARED\n by both parents in a diamond multiple inheritance\n setting so there's no ambiguity. This is not\n the normal order of construction like non-virtual\n inheritance\n\n BLOCK declaring non-virtual base classes\n\n BLOCK declaring ALL data members of A\n\n BODY of A's constructor\n}<\/pre>\n\n\n\n: x(X), y(Y) ...<\/code>} that goes right after the constructor declaration but right before the constructor body, and find the line matching the variables on the list and add {X<\/code>} right after it, to illustrate<\/p>\n\n\n\nint x;\n\/\/ after parsing x(X) item on initializer list becomes\nint x {X};\n\/\/ where X is a blind? substitution of the phrase<\/pre>\n\n\n\n\n\n\n\nclass A\n{\n public: \/\/ struct is class with public by default\n Type1 m1;\n Type2 m2;\n};\nA a;<\/pre>\n\n\n\nType1 A::a_m1;\nType2 A::a_m2;\n\/\/ Constructor of A<\/pre>\n\n\n\n
\n
\/\/ Invalid: consts value must be known at ALL times\nconst bool A::a_m2; \n\/\/ Invalid: refs are bound and sealed on creation\n int& A::a_m1; <\/pre>\n\n\n\n
const bool A::a_m2 = x; \n int& A::a_m1 = y; \n\/\/ Constructor body of A<\/pre>\n\n\n\n
struct A\n{\n A(int x, int y) : x(x), y(y) {}\n int x;\n int& y;\n};<\/pre>\n\n\n\nconst bool A::a_m2 = x; \n int& A::a_m1 = A::a_m2; \n\/\/ Constructor body of A<\/pre>\n\n\n\n
struct A\n{\n A(int X) : x(X), y(x) {}\n int x;\n int& y;\n};<\/pre>\n\n\n\nstruct B { int z; };\nstruct A : public B\n{\n A(int X) : B{7}, x(z+X) {}\n int x;\n};<\/pre>\n\n\n\n\/\/ it's unnamed temporary, \n\/\/ that's why I call it temp_b instead of b\nB::temp_b_z = 7; \n\n\/\/ Create an alias due to inheritance\nA::a_z& B::temp_b_z; \n\n\/\/ 7+X where X is the input to the constructor of A\nA::a_x = A::a_z + X <\/pre>\n\n\n\n
class B\n{\n B(int P, int Q) {y=P+Q;}\n int y;\n};\n\nstruct A\n{\n \/\/ Default constructor method of A goes here\n int x;\n B b;\n};<\/pre>\n\n\n\nB() {...}<\/code>, this first line is established by default<\/p>\n\n\n\nint A::a_x;\n\n\/\/ Invalid, no zero-arg\/default constructor B()\nB A::b; \n\n\/\/ Constructor body of A<\/pre>\n\n\n\n
B(int, int)<\/code>:<\/p>\n\n\n\nint A::a_x;\n\n\/\/ Internally sets A::b.y = 7\nB A::b(3, 4); \n\n\/\/ Constructor body of A<\/pre>\n\n\n\n
struct B\n{\n B(int P, int Q) {y=P+Q;}\n int y;\n};\n\nstruct A\n{\n A() : B(3, 4) {}\n int x;\n B b;\n};<\/pre>\n\n\n\nSetting these values must be done at declaration
(through initialization lists)<\/h2>\n\n\n\nCannot modify after creation
(aka in constructor body)<\/h2>\n\n\n\n\n
const int x = 5;<\/code><\/li>\n\n\n\nint& x = y;<\/code><\/li>\n<\/ul>\n<\/div>\n\n\n\nDefault initialization is not possible
(class\/object has no default ctor)<\/h2>\n\n\n\nstruct B { \n B(int x, int y) \n {z=x+y};\n int z; \n};<\/pre>\n\n\n\n\n
class A { B b; };<\/code><\/li>\n<\/ul>\n\n\n\n\n
class A : public B { \u2026 };<\/code><\/li>\n<\/ul>\n<\/div>\n<\/div>\n