C++中如何无需将子类设为模板即可传递模板类型给孙子类？

我在C++中处理复杂对象依赖关系时，用模板管理对象特化。虽然模板本身复杂，但能避免大量类型转换问题，这点很实用。目前需要将一个类转为模板，仅为了把模板类型传递给父类baseVehicle，但该类Body本身并不关心模板类型——它仅操作该类型的基类baseEngine。这个类包含大量无需特化的逻辑，我希望找到避免重复特化的方法。

简化示例代码 #

cars.h

#include <iostream>

using std::cout, std::endl;

class baseEngine { public: void start() { cout << "vroom" << endl; }};
class GasEngine : public baseEngine {};
class DieselEngine : public baseEngine {};

// 需要模板参数T
template <class T>
class baseVehicle {
    public: T engine;
};

// 仅需传递T给baseVehicle，自身不依赖T的逻辑占多数
template <class T>
class Body : public baseVehicle<T> {
    public:
    void drive();   // 不想为每个engine T重复实现
    void park();    // 部分函数仅用baseEngine接口，不依赖具体T
    void honk();    // 完全不需要使用特化的T
    void brake();   // 有什么可行方案？能否用forward？
    virtual void fillup() = 0;  // 派生类需实现此函数
};

// 依赖特化T的派生类
class GasCar    : public Body<GasEngine> { public: void fillup() {}};
class DieselCar : public Body<DieselEngine> {};
// 后续可能还有HydrogenEngine、NuclearEngine等

// 额外的复杂继承关系
class baseBadge {};
class BlueOval : public baseBadge {};
class baseFord : public BlueOval {};

// 实际需要处理的类
class FordFreestyle : public baseFord, public GasCar {};
class FordRollsCoal : public baseFord, public DieselCar {};

cars.cpp

#include "cars.h"

// 没必要为每个T生成一份副本
template<class T>
void Body<T>::drive() { this->engine.start(); }

// 逻辑上可行但会触发链接错误
template<>
void Body<baseEngine>::drive() { this->engine.start(); }

// 非模板写法逻辑正确，但模板类不允许这样定义
// void Body::drive() { this->engine.start(); }
// void Body::honk() { /* 与engine无关的逻辑 */ }
// void Body::brake() { /* 与engine无关的逻辑 */ }


int main()
{
    FordFreestyle myCar;
    myCar.drive();
    myCar.fillup();

    return 0;
}

可行解决方案 #

方案1：提取非模板基类（推荐）

将Body中所有不依赖模板参数T的逻辑抽离到一个非模板基类中，让模板类Body同时继承这个非模板基类和baseVehicle<T>。这样非模板基类的成员函数只需实现一次，无需随T重复特化。

修改后的代码：

cars.h

#include <iostream>

using std::cout, std::endl;

class baseEngine { public: void start() { cout << "vroom" << endl; }};
class GasEngine : public baseEngine {};
class DieselEngine : public baseEngine {};

template <class T>
class baseVehicle {
    public: T engine;
};

// 非模板基类：存放所有不依赖T的通用逻辑
class BodyBase {
public:
    void park();
    void honk();
    void brake();
    virtual void fillup() = 0; // 保留纯虚函数供派生类实现
};

// 模板类仅负责继承baseVehicle<T>，复用BodyBase的通用逻辑
template <class T>
class Body : public BodyBase, public baseVehicle<T> {
public:
    void drive(); // 仅这个函数需要访问engine，留在模板类中
};

// 派生类定义不变
class GasCar    : public Body<GasEngine> { public: void fillup() {}};
class DieselCar : public Body<DieselEngine> {};

class baseBadge {};
class BlueOval : public baseBadge {};
class baseFord : public BlueOval {};

class FordFreestyle : public baseFord, public GasCar {};
class FordRollsCoal : public baseFord, public DieselCar {};

cars.cpp

#include "cars.h"

// 非模板基类的成员函数只需实现一次
void BodyBase::park() {
    // 通用停车逻辑
}

void BodyBase::honk() {
    // 通用鸣笛逻辑
}

void BodyBase::brake() {
    // 通用刹车逻辑
}

// drive函数依赖baseVehicle<T>的engine，仍需模板实现，但只需写一次
template<class T>
void Body<T>::drive() {
    this->engine.start(); // T继承自baseEngine，可安全调用start
}

// 显式实例化需要用到的模板特化，避免链接错误
template class Body<GasEngine>;
template class Body<DieselEngine>;

int main()
{
    FordFreestyle myCar;
    myCar.drive();
    myCar.fillup();

    return 0;
}

方案2：显式模板实例化+复用实现

如果不想拆分基类，可以在cpp文件中实现模板函数后，显式实例化所有需要用到的Body<T>特化。这种方式下，编译器只会为显式实例化的T生成代码，避免不必要的特化。

比如在cars.cpp中保留模板函数实现，然后添加：

template class Body<GasEngine>;
template class Body<DieselEngine>;

这样编译器只会生成这两个特化的代码，不会为其他未实例化的T生成冗余代码。

关于编译器/链接器的疑问 #

• 对于不依赖T的模板函数，部分编译器会优化掉重复的特化副本，但这不是C++标准强制要求的，不同编译器行为可能存在差异。
• 如果将模板函数实现放在头文件中，每个包含头文件的编译单元都会生成一份特化代码，链接器可能会合并这些副本，但会增加编译时间，这也是不推荐这种写法的原因。

内容的提问来源于stack exchange，提问作者rand'Chris