派生类构造函数如何在内部调用基类构造函数

Question

#include <iostream>
#include <string>
using namespace std;

class A
{
    private:
        int ai;
        string as;
};
class B : public A
{
    private:
        int bi;
        string bs;
};


int main()
{
    B bob;

    return 0;
}

Class A and B have default constructors. And I know that class A default constructor will be called first and then B default constructor. But the question is how that happens internally? Do data members get constructed in the inheritance order? How/where compiler puts call to base ctor from dervied ctor?

Answer 1

Basically base classes are initialized first, then data members in declaration order. One exception is for virtual base classes, which are initialized first and from the most derived class. Another exception is for delegating constructors.

---

Standardeese: in C++11 this is specified by §12.6.2/10:

” In a non-delegating constructor, initialization proceeds in the following order:

• First, and only for the constructor of the most derived class (1.8), virtual base classes are initialized in the order they appear on a depth-first left-to-right traversal of the directed acyclic graph of base classes, where “left-to-right” is the order of appearance of the base classes in the derived class base-specifier-list .
• Then, direct base classes are initialized in declaration order as they appear in the base-specifier-list (regardless of the order of the mem-initializers ).
• Then, non-static data members are initialized in the order they were declared in the class definition (again regardless of the order of the mem-initializers ).
• Finally, the compound-statement of the constructor body is executed.

[ Note: The declaration order is mandated to ensure that base and member subobjects are destroyed in the reverse order of initialization. —end note ]

---

As to how this works internally, a common technique is that a constructor calls its associated base and ordinary member constructors. If you ignore virtual bases and constructor delegation, and consider instantiation of a class T, then when you instantiate T the first that happens is that a T constructor is called. But this is not yet initialization of the T instance itself. The execution is still in the memory initializer list of that constructor. Here it calls the various base and non-base member constructors (where the same happens, recursively). Finally the constructor body is executed.