如何合并两个继承自相似基类的C++相似类？

针对你要合并Car1/Car2、通过单个类实例化指定版本的需求，以下是几种实用的实现方式：

1. 模板类（最简洁的编译时方案） #

把Car设计为模板类，通过模板参数指定要继承的Transport基类，直接复用原有的Transport1/Transport2逻辑，同时统一Car的接口。

// 原有的基类保持不变
class Transport1 {
public:
    void extraMethod() { /* ... */ }
    // 其他公共方法
};

class Transport2 {
public:
    int extraVar;
    // 其他公共方法
};

// 统一的Car模板类
template<typename TransportType>
class Car : public TransportType {
public:
    // 原Car1和Car2的公共逻辑都写在这里
    void drive() { /* ... */ }
};

// 定义别名简化使用
using CarV1 = Car<Transport1>;
using CarV2 = Car<Transport2>;

// 使用方式
int main() {
    CarV1 car1;
    car1.extraMethod(); // 调用Transport1的方法
    car1.drive();

    CarV2 car2;
    car2.extraVar = 10; // 访问Transport2的变量
    car2.drive();
    return 0;
}

这种方式完全复用原有基类，编译时确定版本，代码最简洁，也符合你"引入单个头文件"的需求。

2. 策略模式（支持运行时切换版本） #

如果需要在运行时动态切换版本1/2，可以用组合代替继承，把Transport的逻辑封装成策略，Car类持有策略对象。

// 先定义Transport的抽象基类
class Transport {
public:
    virtual ~Transport() = default;
    // 声明公共接口
    virtual void commonFunc() = 0;
};

// 原Transport1适配为策略类
class Transport1 : public Transport {
public:
    void extraMethod() { /* ... */ }
    void commonFunc() override { /* ... */ }
};

// 原Transport2适配为策略类
class Transport2 : public Transport {
public:
    int extraVar;
    void commonFunc() override { /* ... */ }
};

// 统一的Car类
class Car {
private:
    std::unique_ptr<Transport> transport;
public:
    // 构造时传入指定版本的Transport策略
    explicit Car(std::unique_ptr<Transport> t) : transport(std::move(t)) {}

    void drive() { /* ... */ }

    // 提供访问对应版本特性的接口（需要区分处理）
    void callExtraMethod() {
        if (auto t1 = dynamic_cast<Transport1*>(transport.get())) {
            t1->extraMethod();
        }
        // 版本2不需要此方法，可忽略或抛出异常
    }

    int& getExtraVar() {
        if (auto t2 = dynamic_cast<Transport2*>(transport.get())) {
            return t2->extraVar;
        }
        throw std::runtime_error("Invalid transport version");
    }
};

// 使用方式
int main() {
    auto car1 = std::make_unique<Car>(std::make_unique<Transport1>());
    car1->callExtraMethod();
    car1->drive();

    auto car2 = std::make_unique<Car>(std::make_unique<Transport2>());
    car2->getExtraVar() = 10;
    car2->drive();
    return 0;
}

这种方式适合需要运行时切换版本的场景，但需要额外处理不同版本特性的访问逻辑。

3. 条件编译（单版本编译选择） #

如果只需要在编译时固定选择一个版本，不需要同时支持两个版本，可以用宏控制继承关系：

// 原基类保持不变
class Transport1 {
public:
    void extraMethod() { /* ... */ }
};

class Transport2 {
public:
    int extraVar;
};

// 通过宏选择版本
#ifdef USE_VERSION1
class Car : public Transport1 {
#else
class Car : public Transport2 {
#endif
public:
    void drive() { /* ... */ }
};

// 使用方式：编译时添加-DUSE_VERSION1或不添加
int main() {
    Car car;
#ifdef USE_VERSION1
    car.extraMethod();
#else
    car.extraVar = 10;
#endif
    car.drive();
    return 0;
}

这种方式最简单，但只能编译时确定版本，无法同时使用两个版本。

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