Question

#include <iostream>
#include <string>

using namespace std;

class Person
{
    string name;

    public:
        Person():name("")
        {
            cout << "Person default ctor\n";
        }
        Person(const string& name_in):name(name_in)
        {
            cout << "Person string ctor: " << name << "\n";
        }
        ~Person()
        {
            cout << "Person dtor: " << name << "\n";
        }
        string get_name()
        {
            return name;
        }
};

class Professor:public Person
{
    int office;

    public:
        Professor(const string& name_in, int office_in):Person(name_in), office(office_in)
        {
            cout << "Professor string ctor: " << get_name() << endl;
        }
        ~Professor()
        {
            cout << "Professor dtro: " << get_name() << endl;
        }
};

int main()
{
    Person alice("Alice");
    Professor bob("Bob", 10);

    return 0;
}

我认为输出应该是：

Person string ctor: Alice

Person dtor: Alice

Professor string ctor: Bob

Professor dtor: Bob

因为从逻辑上看，这应该遵循程序的结构。但是，实际输出是：

Person string ctor: Alice

Person string ctor: Bob

Professor string ctor: Bob

Professor dtor: Bob

Person dtor: Bob

Person dtor: Alice

有人可以解释为什么会这样吗？什么我不理解那些让我想出错误输出的类/构造函数/析构函数？

Answer 1

首先，Professor来自Person。这意味着Professor的每个实例都隐式包含Person的实例（观察您在Person(name_in)的构造函数中如何调用Professor）。当Professor对象被销毁时，这个隐式实例将自动被销毁。

这解释了为什么你看到：

Person string ctor: Bob
Person dtor: Bob

对于析构函数调用的顺序，变量以 reverse 构造顺序销毁。这解释了鲍勃在爱丽丝之前被摧毁的原因：

Person string ctor: Alice
Professor string ctor: Bob
Professor dtor: Bob
Person dtor: Alice

Answer 2

因为教授是继承的，所以它会在创建时调用基类构造函数。这就是打印person Bob的原因。

至于反向破坏，这是因为对象的破坏顺序与它们的创建方式相反。

Answer 3

教授“是一个”人，所以当你打电话给教授构造函数时，它的基类的构造函数 - 即Person--将首先被调用。

与desturcter类似，但顺序相反。将首先调用子类的析构函数，然后调用基类。

此外，只有在销毁对象时才会调用析构函数，在您的情况下，仅在当前作用域结束时才会发生。

有人能解释这里发生了什么（类和构造函数/析构函数）吗？

3 个答案: