怎么可能调用了析构函数但在此之前没有构造函数？

Question

我目前正在学习 c++ 的面向对象特性。我写了一段代码来测试继承和多态是如何工作的。 以下是部分代码：

    class Person
{
    public:
    Person()
    {
        cout << "Person constructed\n";
    }

    virtual void introduce()
    {
        cout << "hi from person" << endl;
    }

    ~Person()
    {
        cout << "Person destructed\n";
    }
};

class Student : public Person 
{
    public:
    Student()
    {
        cout << "Student constructed\n";
    }

    void introduce()
    {
        cout << "hi from student" << endl;
    }

    ~Student()
    {
        cout << "Student destructed\n";
    }
};

class Farmer : public Person 
{
    public:
    Farmer()
    {
        cout << "Farmer constructed\n";
    }

    void introduce()
    {
        cout << "hi from farmer" << endl;
    }

    ~Farmer()
    {
        cout << "Farmer destructed\n";
    }
};

class SJW : public Student
{
    public:
    SJW()
    {
        cout << "SJW constructed\n";
    }

    ~SJW()
    {
        cout << "SJW destructed\n";
    }
};

void whoisthis3(Person object)
{
    object.introduce();
}

int main()
{
    Student mark;
    SJW bigred;
    Farmer max;

    cout << endl;

    whoisthis3(mark);
    whoisthis3(max);
    whoisthis3(bigred);

    cout << endl;

    return 0;
}

这是它产生的输出：

Person constructed
Student constructed
Person constructed
Student constructed
SJW constructed
Person constructed
Farmer constructed

hi from person
Person destructed
hi from person
Person destructed
hi from person
Person destructed

Farmer destructed
Person destructed
SJW destructed
Student destructed
Person destructed
Student destructed
Person destructed

这些派生类按预期在开始和结束时被构造和销毁。但是，当 whoisthis3 方法执行时，怎么会调用 Person 析构函数呢？那里发生了什么？

Answer 1

考虑以下简单程序：

struct A 
{
    A() { std::cout << "construct A\n";  }
    ~A() { std::cout << "destruct A\n";  }  
};

int main()
{
  A a;
}

打印出来：

constructs A
destructs A

正如预期的那样。

现在让我们添加一个简单的函数：

void f(A a) {}

然后调用它：

int main()
{
  A a;
  f(a);
}

我们看到了：

construct A
destruct A
destruct A

那么额外的destruct A 是从哪里来的？对应的construct A 在哪里？答案是，当您调用f 时，会调用默认的复制构造函数。如果您在复制构造函数中打印内容，如下所示：

A(A const&) { std::cout << "copy-construct A\n"; }

然后你得到输出：

construct A
copy-construct A
destruct A
destruct A

这表明确实有 2 个对象已经被构造，然后都被销毁了。

另一方面，如果f 像这样通过引用获取参数：

void f(A& a) {}

然后不调用复制构造函数（因为没有复制），输出将是：

construct A
destruct A

Answer 2

void whoisthis3(Person object)
{
    object.introduce();
}

此函数按值接受其object 参数。这意味着将创建一个新的Person 对象作为您传递给whoisthis3 的对象的副本。由于您没有显式定义Person 的复制构造函数，因此它使用编译器生成的默认复制构造函数。当函数结束时，它的object 参数被销毁，你会看到它的析构函数打印的语句。

---

请注意，正如您所观察到的，whoisthis3 将始终调用Person::introduce，因为object 是Person，而不是任何派生自它的类型。这通常称为object slicing。