MST

星途 面试题库

面试题：C++虚拟函数与普通成员函数在多重继承和菱形继承场景下的行为差异

在多重继承和菱形继承的复杂场景中，C++虚拟函数和普通成员函数的行为表现有哪些不同？请通过详细的代码示例和内存模型分析来解释这些差异，并讨论如何避免因这些差异可能导致的问题。
11.4万 热度难度
编程语言C++

知识考点

AI 面试

面试题答案

一键面试

1. 虚拟函数与普通成员函数行为差异

虚拟函数

  • 动态绑定：虚拟函数支持运行时多态，根据对象的实际类型来决定调用哪个函数版本。这意味着即使通过基类指针或引用调用，也会调用到派生类中重写的版本。
  • 存在虚函数表：每个包含虚拟函数的类都有一个虚函数表（vtable），对象的内存布局中会有一个指向该虚函数表的指针（vptr）。

普通成员函数

  • 静态绑定：普通成员函数在编译时就确定了调用哪个函数版本，根据指针或引用的类型决定，而不是对象的实际类型。
  • 没有虚函数表相关开销：普通成员函数直接通过对象地址加上偏移量来调用，不存在虚函数表和虚指针。

2. 代码示例

多重继承

#include <iostream>

class Base1 {
public:
    virtual void virtualFunction() {
        std::cout << "Base1::virtualFunction" << std::endl;
    }
    void normalFunction() {
        std::cout << "Base1::normalFunction" << std::endl;
    }
};

class Base2 {
public:
    virtual void virtualFunction() {
        std::cout << "Base2::virtualFunction" << std::endl;
    }
    void normalFunction() {
        std::cout << "Base2::normalFunction" << std::endl;
    }
};

class Derived : public Base1, public Base2 {
public:
    void virtualFunction() override {
        std::cout << "Derived::virtualFunction" << std::endl;
    }
    void normalFunction() {
        std::cout << "Derived::normalFunction" << std::endl;
    }
};

int main() {
    Derived d;
    Base1* b1Ptr = &d;
    Base2* b2Ptr = &d;

    b1Ptr->virtualFunction();  // 调用 Derived::virtualFunction
    b2Ptr->virtualFunction();  // 调用 Derived::virtualFunction

    b1Ptr->normalFunction();   // 调用 Base1::normalFunction
    b2Ptr->normalFunction();   // 调用 Base2::normalFunction

    return 0;
}

菱形继承

#include <iostream>

class Base {
public:
    virtual void virtualFunction() {
        std::cout << "Base::virtualFunction" << std::endl;
    }
    void normalFunction() {
        std::cout << "Base::normalFunction" << std::endl;
    }
};

class Derived1 : virtual public Base {
public:
    void virtualFunction() override {
        std::cout << "Derived1::virtualFunction" << std::endl;
    }
    void normalFunction() {
        std::cout << "Derived1::normalFunction" << std::endl;
    }
};

class Derived2 : virtual public Base {
public:
    void virtualFunction() override {
        std::cout << "Derived2::virtualFunction" << std::endl;
    }
    void normalFunction() {
        std::cout << "Derived2::normalFunction" << std::endl;
    }
};

class FinalDerived : public Derived1, public Derived2 {
public:
    void virtualFunction() override {
        std::cout << "FinalDerived::virtualFunction" << std::endl;
    }
    void normalFunction() {
        std::cout << "FinalDerived::normalFunction" << std::endl;
    }
};

int main() {
    FinalDerived fd;
    Base* basePtr = &fd;
    Derived1* d1Ptr = &fd;
    Derived2* d2Ptr = &fd;

    basePtr->virtualFunction();  // 调用 FinalDerived::virtualFunction
    d1Ptr->virtualFunction();    // 调用 FinalDerived::virtualFunction
    d2Ptr->virtualFunction();    // 调用 FinalDerived::virtualFunction

    basePtr->normalFunction();   // 调用 Base::normalFunction
    d1Ptr->normalFunction();     // 调用 Derived1::normalFunction
    d2Ptr->normalFunction();     // 调用 Derived2::normalFunction

    return 0;
}

3. 内存模型分析

虚拟函数内存模型

  • 在多重继承中，每个基类部分都有自己的虚函数表指针（vptr），指向各自的虚函数表。在菱形继承中，由于虚继承，只有一个共享的基类子对象，所以只有一个指向基类虚函数表的指针。
  • 当调用虚拟函数时，通过对象的虚指针找到虚函数表，然后根据函数在表中的索引调用相应的函数版本。

普通成员函数内存模型

  • 普通成员函数直接存储在代码段中，通过对象地址加上函数偏移量来调用。在多重继承和菱形继承中，普通成员函数的调用方式不受继承结构影响，仅取决于指针或引用的类型。

4. 避免问题的方法

避免命名冲突

  • 在多重继承和菱形继承中，不同基类可能有同名的普通成员函数，这可能导致调用歧义。可以通过作用域解析运算符（::）明确指定调用哪个基类的函数。

正确使用虚拟函数

  • 确保在派生类中正确重写虚拟函数，使用override关键字可以帮助编译器检查重写是否正确。
  • 注意虚继承的使用，以避免基类子对象的重复，减少内存浪费和潜在的二义性问题。

设计合理的继承结构

  • 尽量简化继承结构，避免过度复杂的多重继承和菱形继承，优先考虑组合等其他设计模式，以提高代码的可读性和维护性。