C++多重继承中，派生类如何按需调用对应父类函数

当然可行！咱们可以通过在C类中维护一个选择标记，结合显式调用父类成员函数的方式实现需求，同时也能针对你的场景给出更优雅的替代设计方案。

一、直接实现方式 #

核心思路很简单：

• 在C类中添加一个成员变量，存储构造时传入的选择标记
• 在C::func()中根据标记，显式调用A或B的func()方法

完整代码示例：

#include <iostream>
using namespace std;

class Base { 
public:
    virtual void func() { cout << "func base" << endl; } 
}; 

class A : virtual public Base { 
public:
    virtual void func() { cout << "func A" << endl; } 
}; 

class B : virtual public Base { 
public:
    virtual void func() { cout << "func B" << endl; } 
}; 

class C : public A, public B { 
private:
    bool is_a_; // 存储构造时的选择标记
public:
    C(bool is_a) : is_a_(is_a) {} // 构造函数初始化标记
    virtual void func() { 
        if (is_a_) {
            A::func(); // 必须显式指定父类，避免递归调用自身的func()
        } else {
            B::func();
        }
    } 
}; 

int main() {
    Base* ptr = new C(true); 
    ptr->func(); // 输出 "func A"
    
    Base* ptr2 = new C(false);
    ptr2->func(); // 输出 "func B"
    
    delete ptr;
    delete ptr2;
    return 0;
}

这里要注意：一定要用A::func()这种显式调用方式，直接写func()会无限递归调用C自己的func()。

二、替代设计方案（更符合设计原则） #

你提到C只会以A或B中的一个作为实际父类，这种情况下多重继承可能会带来不必要的复杂性（比如菱形继承的潜在歧义问题），推荐两种更优雅的替代方案：

1. 组合模式 + 工厂方法 #

把A和B作为C的内部成员而非父类，同时把A/B的共用功能抽离到独立类中，通过工厂方法封装C的创建逻辑：

#include <iostream>
#include <memory>
using namespace std;

class Base { 
public:
    virtual void func() = 0;
    virtual ~Base() = default;
}; 

class A : public Base { 
public:
    void func() override { cout << "func A" << endl; } 
    // A的独有功能
}; 

class B : public Base { 
public:
    void func() override { cout << "func B" << endl; } 
    // B的独有功能
}; 

// 提取A和B的共用功能到独立类
class CommonFeatures {
public:
    void sharedFunc() { cout << "shared function" << endl; }
};

class C : public Base, private CommonFeatures { 
private:
    unique_ptr<Base> impl_;
public:
    C(bool is_a) {
        impl_ = is_a ? make_unique<A>() : make_unique<B>();
    }
    
    void func() override {
        impl_->func();
    }
    
    // 暴露共用功能给外部
    using CommonFeatures::sharedFunc;
}; 

// 可选：用工厂方法封装C的创建逻辑，更简洁
unique_ptr<C> createC(bool is_a) {
    return make_unique<C>(is_a);
}

这种方式彻底避免了多重继承的复杂性，同时清晰分离了“共用功能”和“具体实现”。

2. 策略模式 #

如果A和B的核心差异仅在于func()的实现，可以把这部分逻辑抽象为策略接口，让C持有不同的策略对象：

#include <iostream>
#include <memory>
using namespace std;

// 定义策略接口
class FuncStrategy {
public:
    virtual void execute() = 0;
    virtual ~FuncStrategy() = default;
};

// 对应A的策略实现
class StrategyA : public FuncStrategy {
public:
    void execute() override { cout << "func A" << endl; }
};

// 对应B的策略实现
class StrategyB : public FuncStrategy {
public:
    void execute() override { cout << "func B" << endl; }
};

// 共用功能类
class CommonFeatures {
public:
    void sharedFunc() { cout << "shared function" << endl; }
};

class C : public CommonFeatures {
private:
    unique_ptr<FuncStrategy> strategy_;
public:
    C(bool useA) {
        strategy_ = useA ? make_unique<StrategyA>() : make_unique<StrategyB>();
    }
    
    void func() {
        strategy_->execute();
    }
};

这种方式扩展性极强，后续如果需要新增类似A/B的实现，只需要新增策略类即可，完全不用修改C的代码。

内容的提问来源于stack exchange，提问作者nishantsingh