C++父类析构中调用的虚函数，子类重写虚函数，最后调用的是谁的虚函数

在C++中，当一个类中定义了虚函数，如果该类有子类继承它并且重写了该虚函数，那么在使用子类对象时，调用该虚函数会优先调用子类重写的虚函数。

对于析构函数，如果父类中定义了虚析构函数，那么在使用子类对象时，会先调用子类的析构函数，然后再调用父类的析构函数。如果子类没有定义析构函数，那么会直接调用父类的析构函数。

因此，在父类析构函数中调用虚函数时，如果子类重写了该虚函数，最后调用的就是子类重写的虚函数。

相关问题

C++ 父类中有一个函数A,子类重写了函数A, 如何实现在父类的B函数中调用子类的A函数

在 C++ 中，如果你想在父类 B 函数中调用子类重写后的 A 函数，你可以通过指针或者引用来实现 polymorphism（多态）。这里是一个简单的例子：

class Base {
public:
    virtual void A() { // 父类的 A 函数
        std::cout << "Base Class: calling A()\n";
    }
    
    void B() {
        // 创建子类的对象指针或者引用
        Derived* derivedPtr = dynamic_cast<Derived*>(&someObject); // 假设 someObject 是 Base 的实例

        if (derivedPtr) {
            // 调用子类的 A 函数
            derivedPtr->A();  // 这里会执行 Derived 类型下的 A 实现
        } else {
            // 如果无法动态转换（即 someObject 不是 Derived），可以处理异常或默认行为
            std::cout << "Derived not available for call in B()\n";
        }
    }
};

class Derived : public Base {
public:
    override void A() override { // 子类的 A 函数
        std::cout << "Derived Class: overriding A()\n";
    }
};

// 使用示例
Base baseObj;
Derived derivedObj;

baseObj.B(); // 输出：Base Class: calling A()
derivedObj.B(); // 输出：Derived Class: overriding A()

在这个例子中，`B` 函数通过 `dynamic_cast` 将 `Base` 类型转换为 `Derived` 类型，如果成功则可以安全地调用 `A` 函数，因为此时指向的是 `Derived` 对象。如果转换失败，说明不是 `Derived` 类型，程序会提供默认的行为。

父类是虚类，父类中有一个函数a调用了父类的虚函数，在子类中重写了这个虚函数，父类指针指向子类对象时，调用函数a出现：引发异常，读取访问权限冲突

在父类是虚类的情况下，当父类中的函数a调用了父类的虚函数，并且在子类中重写了这个虚函数时，如果父类指针指向子类对象，调用函数a可能会引发异常，出现访问权限冲突的情况。

这是因为在C++中，虚函数的调用是通过虚函数表来实现的。当父类指针指向子类对象时，调用函数a时会先在父类的虚函数表中查找对应的虚函数，然后调用该虚函数。但是由于子类重写了父类的虚函数，子类的虚函数表中的对应位置存储的是子类的虚函数地址。因此，当父类指针指向子类对象时，调用函数a时会去父类的虚函数表中查找虚函数地址，但实际上调用的是子类的虚函数。

这样就会导致访问权限冲突的问题。因为父类中的函数a可能依赖于父类的虚函数的实现，而子类重写了这个虚函数，可能会改变虚函数的行为，导致函数a的逻辑出现问题。

为了避免这种访问权限冲突的问题，可以在父类中将虚函数声明为纯虚函数，即在函数声明后面加上`= 0`。这样父类就成为了抽象类，不能直接实例化对象，只能作为基类被继承。子类必须实现纯虚函数，否则子类也会成为抽象类。

示例代码如下所示：

class Base {
public:
    virtual void func() = 0; // 纯虚函数
};

class Derived : public Base {
public:
    void func() override {
        // 子类实现纯虚函数
        // 具体的实现逻辑
    }
};

int main() {
    Base* ptr = new Derived(); // 父类指针指向子类对象
    ptr->func(); // 调用虚函数
    delete ptr;
    return 0;
}

这样，父类指针指向子类对象时，调用函数a就不会出现访问权限冲突的问题了。