Question

我有以下代码：

class A {
    public:
        A() { cout << "A-C" << endl; }
        ~A(){ cout << "A-D" << endl; }
};

class B {
    public:
        B() { 
            cout << "B-C" << endl; 
        }
        ~B() { 
            cout << "B-D" << endl; 
        } 
};

class C {
    protected:
        A* a;
        B b;
    public: 
        C() {
              a = new A;
              cout << "C-C" << endl; 
            }
        ~C() { 
            delete a;
            cout << "C-D" << endl; 
        }
};

class D : public C {
    protected:
        A a;
        B b;
    public:
        D(){ cout << "D-C" << endl; }
        ~D(){ cout << "D-D" << endl; }
};

int main() {
    D* d = new D;
    B* b = new B;

    delete b;
    delete d;

    system("pause");
    return 0;
}

我对输出的初步想法是：

A-C
C-C
A-C
B-C
D-C
B-C
B-D
D-D
B-D
A-D
A-D
C-D

但这是错的。输出实际上是：

B-C
A-C
C-C
A-C
B-C
D-C
B-C
B-D
D-D
B-D
A-D
A-D
C-D
B-D

我不知道为什么程序最先调用B的构造函数，最后调用它的析构函数。我认为构造函数调用的顺序应该是这样的： C的构造函数 - ＆gt; A的构造函数 - ＆gt; B的构造函数 - ＆gt; D的构造函数。

析构函数调用的顺序与构造函数调用的顺序相反

任何人都可以告诉我为什么在开始时调用B的构造函数并且最后调用B的析构函数？

Answer 1

B-C
A-C
C-C
A-C
B-C
D-C

所有这些都是由D* d = new D;引起的。

D构造函数调用C构造函数，因为C是D的基础。

然后，类a的数据成员b和C被初始化，a是一个指针，因此没有构造函数调用该数据成员。 b是B类型的对象，因此调用B无参数构造函数，为您提供第一个B-C。

然后在C构造函数中，您说new A调用A的构造函数，该构造函数为A-C后跟C-C。

然后，D类的数据成员a和b被初始化，两者都是对象，因此两个构造函数都被调用，为您提供A-C和B-C。

最后，调用D构造函数，以D-C结束。

关于构造函数调用和继承的顺序的一些混淆

1 个答案: