Question

我不确定代码是如何工作的。如何 A c0 = new C（）; *甚至工作？如何从'C'创建指针'A'对象？

class A {
public:
    A() { print("Constructor of A"); }
    virtual ~A() { print("Destructor of A"); }
};

class B : public A {
public:
    B() { print("Constructor of B"); }
    ~B() { print("Destructor of B"); }
};

class C : public B {
public:
    C() { print("Constructor of C"); }
    ~C() { print("Destructor of C"); }
};

int main() {
    print("A* = C");
    A* c0 = new C();
    delete c0;

    print("B* = C");
    B* c1 = new C();
    delete c1;

    print("C* = C");
    C* c2 = new C();
    delete c2;

    return 0;
}

我以为我很久以前就理解了继承，但现在当我需要使用它时，我只是迷失在代码中。

Answer 1

由于B继承自A，C继承自A，C间接继承自A。因此，C*的每个实例也是A*的实例。因此，类型{{1}}的值可以直接转换为{{1}}类型的值。

Answer 2

欢迎继承!! 持续的继承等级说实话。

*************************************
A Base
B Base + (Something )
C Base + (Something ) + (Something ) 
**************************************

请记住上面的图片..所以现在你可以看到C包含绝对是A本身的Base ..所以这个东西对你有用..

Answer 3

由于C是从A派生的，因此所有C对象都是（isA）A。 new运算符创建一个C，由于C“isA”A，它可以分配给A *指针。

使用A *指针时，只能调用A类中定义的函数。（因为指针类型为A）

当你有一个指向C对象的C *指针时，你可以调用A，B或C中的任何函数。（假设它们是公共的或受保护的）。

如果您有一个虚函数“f”，并且在每个类中定义了非虚函数“g”，并且具有以下赋值：

A * pA =新A; A * pAC =新C; C * pC =新C;

然后，

pA-＆gt; f（）将调用A :: f（）; pA-> g（）将调用A :: g（）;

pAC-＆gt; f（）将调用A :: f（）; pAC-＆gt; g（）将调用C :: g（）;

pC-＆gt; f（）将调用C :: f（）; pC-＆gt; g（）将调用C :: g（）;

请注意，实际感兴趣的区域在pAC示例中。调用虚函数始终调用实际对象的实现。调用plain函数会根据指针类型调用实现。

继承如何在这里工作？

3 个答案: