C++中如何重写两个继承同一基类的父类的虚方法？

在C++开发中会遇到这类场景：一个类多继承两个父类，而这两个父类都继承自同一个带虚方法的基类。需要在多继承子类中分别重写两个父类的虚方法，但用类似命名空间的方式实现会编译报错，直接重写虚方法又会导致两个父类共用同一个实现。

问题示例代码1 #

#include <iostream>

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

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

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

class DerivedUnion : public Derived1, public Derived2
{
    public:
    void Derived1::f() override { // 编译错误

    }

    void Derived2::f() override { // 编译错误

    }

};

尝试的错误写法 #

直接在类内部用命名空间式的限定符会编译报错，仅重写一次则会让两个父类共用同一实现：

class DerivedUnion : public Derived1, public Derived2 
   // 注意：DerivedUnion并非Union，仅为演示命名，不实现Union行为
{
    public:
    virtual void Derived1::f() override; // 编译错误
    virtual void Derived2::f() override; // 编译错误
    virtual void f() override; // 无编译错误，但Derived1和Derived2会调用同一实现
};

void UseBase(Base* b){
       b->f(); // 预期编译时出现歧义调用
       b->DerivedUnion::f() // 预期调用重写后的DerivedUnion::f()
       b->Derived1::f(); // 预期调用重写后的Derived1::f()
       b->Derived2::f(); // 预期调用重写后的Derived2::f()
}

实际场景示例（按钮组件） #

#include <iostream>

/* 可绘制接口 */
class IDrawable {
    public:
    
    virtual void Draw() {};
};

/* 假设这是某类工具栏中的按钮 */
class ButtonA : public IDrawable{
    public:
    virtual void Draw() override {
        std::cout << "ButtonA::Draw()" << std::endl;
    }
};

/* 假设这是另一类工具栏中的按钮 */
class ButtonB : public IDrawable{
    public:
    virtual void Draw() override {
        std::cout << "ButtonB::Draw()" << std::endl;
    }
};

/**
ComponentX是可表示两种按钮类型的组件
*/
class ComponentX : public ButtonA, public ButtonB {
    public:
    void ButtonA::Draw() override { // 无法在ComponentX内定义ButtonA::Draw
        ButtonA::Draw();
        std::cout << "Custom ComponentX::Draw()" << std::endl;
    }
    
    void ButtonB::Draw() override { // 错误：无法在ComponentX内定义ButtonB::Draw
        ButtonB::Draw();
        std::cout << "Custom ComponentX::Draw()" << std::endl;
    }
};

class ComponentY : public ButtonA, public ButtonB {
    public:
    void ButtonA::Draw() override { // 无法在ComponentY内定义ButtonA::Draw
        ButtonA::Draw();
        std::cout << "Custom ComponentY::Draw()" << std::endl;
    }
    
    void ButtonB::Draw() override { // 错误：无法在ComponentY内定义ButtonB::Draw
        ButtonB::Draw();
        std::cout << "Custom ComponentY::Draw()" << std::endl;
    }
};

using namespace std;

void DummyAddButtonA(ButtonA* pBtnA)
{
    // 将其添加到某处...
}

void DummyAddButtonB(ButtonB* pBtnB)
{
    // 将其添加到某处...
}

int main()
{
    ComponentX compx;
    ComponentY compy;
    
    DummyAddButtonA(&compx);
    DummyAddButtonB(&compx);

    DummyAddButtonA(&compy);
    DummyAddButtonB(&compy);
    
    return 0;
}

可行解决方案：类外部用作用域限定符分别实现 #

要分别重写两个父类的虚方法，不能在类内部直接用父类作用域限定，而是需要在类外部通过完整作用域限定符来实现不同版本的虚方法，类内部仅声明重写。

修改后的基础示例实现 #

#include <iostream>

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

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

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

class DerivedUnion : public Derived1, public Derived2
{
public:
    // 仅声明要重写f()，具体实现放在类外
    void f() override;
};

// 实现针对Derived1的重写版本
void DerivedUnion::Derived1::f() {
    std::cout << "DerivedUnion overriding Derived1::f()" << std::endl;
}

// 实现针对Derived2的重写版本
void DerivedUnion::Derived2::f() {
    std::cout << "DerivedUnion overriding Derived2::f()" << std::endl;
}

int main() {
    DerivedUnion du;
    // 通过类型转换明确调用哪个父类版本的重写方法
    static_cast<Derived1&>(du).f();
    static_cast<Derived2&>(du).f();
    
    // 注意：直接调用du.f()会编译报错，因为存在歧义，必须明确指定父类作用域或转换类型
    return 0;
}

按钮组件场景的修改实现 #

#include <iostream>

/* 可绘制接口 */
class IDrawable {
public:
    virtual void Draw() {};
};

/* 假设这是某类工具栏中的按钮 */
class ButtonA : public IDrawable{
public:
    virtual void Draw() override {
        std::cout << "ButtonA::Draw()" << std::endl;
    }
};

/* 假设这是另一类工具栏中的按钮 */
class ButtonB : public IDrawable{
public:
    virtual void Draw() override {
        std::cout << "ButtonB::Draw()" << std::endl;
    }
};

/**
ComponentX是可表示两种按钮类型的组件
*/
class ComponentX : public ButtonA, public ButtonB {
public:
    void Draw() override;
};

// 重写ButtonA的Draw()，保留基类逻辑并添加自定义内容
void ComponentX::ButtonA::Draw() {
    ButtonA::Draw();
    std::cout << "Custom ComponentX::ButtonA::Draw()" << std::endl;
}

// 重写ButtonB的Draw()，保留基类逻辑并添加自定义内容
void ComponentX::ButtonB::Draw() {
    ButtonB::Draw();
    std::cout << "Custom ComponentX::ButtonB::Draw()" << std::endl;
}

class ComponentY : public ButtonA, public ButtonB {
public:
    void Draw() override;
};

void ComponentY::ButtonA::Draw() {
    ButtonA::Draw();
    std::cout << "Custom ComponentY::ButtonA::Draw()" << std::endl;
}

void ComponentY::ButtonB::Draw() {
    ButtonB::Draw();
    std::cout << "Custom ComponentY::ButtonB::Draw()" << std::endl;
}

using namespace std;

void DummyAddButtonA(ButtonA* pBtnA)
{
    pBtnA->Draw(); // 自动调用ComponentX/ComponentY重写后的ButtonA::Draw()
}

void DummyAddButtonB(ButtonB* pBtnB)
{
    pBtnB->Draw(); // 自动调用ComponentX/ComponentY重写后的ButtonB::Draw()
}

int main()
{
    ComponentX compx;
    ComponentY compy;
    
    cout << "=== ComponentX 调用测试 ===" << endl;
    DummyAddButtonA(&compx);
    DummyAddButtonB(&compx);

    cout << "\n=== ComponentY 调用测试 ===" << endl;
    DummyAddButtonA(&compy);
    DummyAddButtonB(&compy);
    
    return 0;
}

关键说明 #

1. 类内部仅声明重写的虚方法，不写具体实现；
2. 类外部通过子类::父类::方法名的完整作用域限定，分别实现对应父类的虚方法版本；
3. 调用时，通过类型转换（如static_cast<父类&>(子类对象)）或明确的作用域限定，指定调用哪个版本的方法，避免歧义；
4. 这种方式既满足了分别重写不同父类虚方法的需求，也符合C++的语法规则。

内容的提问来源于stack exchange，提问作者Jôsúa