Question

我有一个获取'A'对象的函数，它被称为：func。我发送了一个B的对象。

它不应该激活B的构造函数吗？因为我发送了B的对象，虽然我必须发送一个A的对象。我真的不知道为什么这个函数会打印出来：

A()
DESTRUCTOR A

而不是：

CONSTRUCTOR A
CONSTRUCTOR B
B()
DESTRUCTOR B
DESTRUCTOR A

是否必须将对象B相乘，因为func得到A a而不是A& a？

这是我的代码：

class A
{
  public:
    A() { cout << "CONSTRUCTOR A\n"; }
    ~A() { cout << "DESTRUCTOR A\n"; }
    virtual void f() { cout << "A()" << endl; }
};

class B: public A
{
  public:
    B() { cout << "CONSTRUCTOR B\n"; }
    ~B() { cout << "DESTRUCTOR B\n"; }
    virtual void f() { cout << "B()" << endl; }
};

void func(A a) {
    a.f();
}

int main() {
    B b;
    func(b);
    return 0;
}

Answer 1

因为如果你送儿子但是这个功能要求父亲上课，那就把孩子视为父亲。

class A
{
  public:
    A() { cout << "CONSTRUCTOR A\n"; }
    ~A() { cout << "DESTRUCTOR A\n"; }
    virtual void f() { cout << "A()" << endl; }
};

class B: public A
{
  public:
    B() { cout << "CONSTRUCTOR B\n"; }
    ~B() { cout << "DESTRUCTOR B\n"; }
    virtual void f() { cout << "B()" << endl; }
};

void func(B a) {
    a.f();
}

int main() {
    B b;
    func(b);
    return 0;
}

如果您尝试使用此代码，则会看到您期望的结果。

Answer 2

我认为您感到困惑的原因是因为您通过值而不是指针传递。这就是为什么B对象被视为A的原因，因为func取值为A，默认情况下它将对象视为A，这也意味着正在调用错误的析构函数。运行此代码，您将更好地理解。 / p>

#include <iostream>

using namespace std;

class A
{
  public:
    A() { cout << "CONSTRUCTOR A\n"; }
    ~A() { cout << "DESTRUCTOR A\n"; }
    virtual void f() { cout << "A()" << endl; }
};

class B: public A
{
  public:
    B() { cout << "CONSTRUCTOR B\n"; }
    ~B() { cout << "DESTRUCTOR B\n"; }
    virtual void f() { cout << "B()" << endl; }
};

void func(A * a) {
    a->f();
}

int main() {
    B * b = new B();;
    cout << "\n";
    func(b);
    cout << "\n";
    delete b;
    return 0;
}

这基本上是虚函数的重点，当使用继承时，您希望能够将所有内容作为父类指针传递。但是，您想要调用的方法是子类方法。当您通过值传递时，必须将对象视为传入的对象。

发送儿子的对象而不是父亲

2 个答案: