显式模板实例化与组合爆炸：策略模式是否仍需大量实例化？

嘿，这个问题我太有共鸣了——当初我在做类似的组件组合系统时也踩过这个模板实例化的坑！先直接给你结论：你现在的显式实例化所有组合的做法，其实背离了策略模式的核心意图，咱们一步步捋清楚。

你想用它规避“组合爆炸”是完全正确的，但现在硬写343行模板实例化，本质上是把“逻辑的组合爆炸”变成了“代码量的爆炸”，这显然不是策略模式要解决的问题。

大概率是你把Worker、Location、Behavior这三个组件都做成了模板参数，比如写了这样的模板类：

template <typename Worker, typename Location, typename Behavior>
class WorkerStrategy {
public:
    void run() {
        Worker worker;
        Location loc;
        Behavior behavior;
        // 执行组合逻辑
    }
};

这种模板硬绑定的方式，确实会逼你显式实例化所有可能的组合——因为C++模板只有在实例化时才会生成具体代码。但这其实是把策略模式用成了静态模板组合，而非真正的策略模式。

应该把每个组件定义成抽象基类，具体实现继承自基类，然后通过指针/引用动态注入到上下文类中，完全不需要模板：

第一步：定义抽象策略接口 #

// 抽象Worker接口
class IWorker {
public:
    virtual ~IWorker() = default;
    virtual void performWork() = 0;
};

// 抽象Location接口
class ILocation {
public:
    virtual ~ILocation() = default;
    virtual void setupLocation() = 0;
};

// 抽象Behavior接口
class IBehavior {
public:
    virtual ~IBehavior() = default;
    virtual void executeBehavior() = 0;
};

第二步：实现具体组件 #

// 比如具体的WorkerA
class WorkerA : public IWorker {
    void performWork() override {
        // WorkerA的具体逻辑
    }
};

// 具体的LocationB
class LocationB : public ILocation {
    void setupLocation() override {
        // LocationB的具体逻辑
    }
};

// 其他具体组件同理，每个都继承对应的抽象类

第三步：上下文类（策略模式的核心） #

这个类负责组合三个组件，并且支持动态切换：

class WorkerContext {
private:
    std::unique_ptr<IWorker> worker_;
    std::unique_ptr<ILocation> location_;
    std::unique_ptr<IBehavior> behavior_;

public:
    // 构造时注入组件，或者提供setter动态替换
    WorkerContext(std::unique_ptr<IWorker> w, std::unique_ptr<ILocation> l, std::unique_ptr<IBehavior> b)
        : worker_(std::move(w)), location_(std::move(l)), behavior_(std::move(b)) {}

    void runTask() {
        worker_->performWork();
        location_->setupLocation();
        behavior_->executeBehavior();
        // 你的组合逻辑
    }

    // 动态切换组件的方法
    void setWorker(std::unique_ptr<IWorker> w) { worker_ = std::move(w); }
    void setLocation(std::unique_ptr<ILocation> l) { location_ = std::move(l); }
    void setBehavior(std::unique_ptr<IBehavior> b) { behavior_ = std::move(b); }
};

这样一来，你根本不需要写任何模板实例化代码！客户端可以根据需求动态组合任意组件：

// 组合WorkerA + LocationB + BehaviorC
auto context = std::make_unique<WorkerContext>(
    std::make_unique<WorkerA>(),
    std::make_unique<LocationB>(),
    std::make_unique<BehaviorC>()
);
context->runTask();

// 随时切换成WorkerD + LocationE + BehaviorF
context->setWorker(std::make_unique<WorkerD>());
context->setLocation(std::make_unique<LocationE>());
context->setBehavior(std::make_unique<BehaviorF>());
context->runTask();

如果你的组件是无状态且对性能要求极高（比如游戏引擎里的高频逻辑），虚函数的开销不能接受，那模板版本是可以的，但也不用显式实例化所有组合——而是让客户端在需要的时候才实例化对应的组合：

// 只实例化实际用到的组合，而不是343种全写
WorkerStrategy<WorkerA, LocationB, BehaviorC> strategy1;
strategy1.run();

WorkerStrategy<WorkerD, LocationE, BehaviorF> strategy2;
strategy2.run();

这样只有用到的组合才会生成代码，不会产生冗余的实例化代码。

• 你现在的显式实例化所有组合的做法，确实不符合策略模式“避免组合爆炸、支持动态切换”的核心
• 优先用抽象接口+动态注入的方式，这才是策略模式的标准用法，完全解决了组合爆炸的问题
• 如果追求极致性能用模板，也只实例化实际用到的组合，不要提前硬写所有可能的情况

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