模板策略模式怎么实现 编译期多态方案

模板策略模式通过编译期多态在编译时确定策略，避免虚函数调用开销，提升性能；使用类型擦除可减少代码膨胀，而运行时动态切换策略可通过函数指针或跳转表实现，在灵活性与性能间取得平衡。

模板策略模式，本质上是为了解决算法族中，核心流程固定但具体步骤可变的问题。编译期多态方案，则是在编译时确定具体使用哪个策略，避免运行时的虚函数调用开销，提高性能。

解决方案

模板策略模式的核心在于定义一个模板方法，这个方法定义了算法的骨架，而将一些步骤延迟到子类去实现。编译期多态，意味着我们希望在编译时就确定使用哪个子类（策略）。这通常可以通过模板元编程来实现。

#include 
#include 

// 策略接口
template 
struct Strategy {
    virtual ~Strategy() = default;
    virtual void execute(T& data) = 0;
};

// 具体策略 A
template 
struct ConcreteStrategyA : public Strategy {
    void execute(T& data) override {
        std::cout << "ConcreteStrategyA executing with data: " << data << std::endl;
        data += 1;
    }
};

// 具体策略 B
template 
struct ConcreteStrategyB : public Strategy {
    void execute(T& data) override {
        std::cout << "ConcreteStrategyB executing with data: " << data << std::endl;
        data *= 2;
    }
};

// 模板类，接受策略类型作为模板参数
template  typename StrategyType>
class Context {
public:
    Context() : strategy(new StrategyType()) {} // 编译期确定策略类型
    ~Context() { delete strategy; }

    void processData(T& data) {
        strategy->execute(data);
    }

private:
    Strategy* strategy; // 指向策略对象的指针
};

int main() {
    int data = 5;
    Context contextA; // 编译期绑定 ConcreteStrategyA
    contextA.processData(data); // 输出 "ConcreteStrategyA executing with data: 5"， data变为6

    int data2 = 10;
    Context contextB; // 编译期绑定 ConcreteStrategyB
    contextB.processData(data2); // 输出 "ConcreteStrategyB executing with data: 10"， data2变为20
    return 0;
}

这段代码展示了基本的实现。

Context

如何避免代码膨胀？

编译期多态的一个潜在问题是代码膨胀，因为每个不同的策略组合都会生成一个新的

Context

#include 
#include 

template 
class AnyStrategy {
public:
    using ExecuteFunc = std::function;

    AnyStrategy(ExecuteFunc func) : executeFunc(func) {}

    void execute(T& data) {
        executeFunc(data);
    }

private:
    ExecuteFunc executeFunc;
};

template 
struct ConcreteStrategyA {
    void operator()(T& data) {
        std::cout << "ConcreteStrategyA executing with data: " << data << std::endl;
        data += 1;
    }
};

template 
struct ConcreteStrategyB {
    void operator()(T& data) {
        std::cout << "ConcreteStrategyB executing with data: " << data << std::endl;
        data *= 2;
    }
};

template 
class Context {
public:
    Context(AnyStrategy strategy) : strategy(strategy) {}

    void processData(T& data) {
        strategy.execute(data);
    }

private:
    AnyStrategy strategy;
};

int main() {
    int data = 5;
    Context contextA(AnyStrategy(ConcreteStrategyA()));
    contextA.processData(data);

    int data2 = 10;
    Context contextB(AnyStrategy(ConcreteStrategyB()));
    contextB.processData(data2);
    return 0;
}

这里

AnyStrategy

std::function

Context

T

AnyStrategy

唱鸭

音乐创作全流程的AI自动作曲工具，集 AI 辅助作词、AI 自动作曲、编曲、混音于一体

下载

编译期策略选择的更高级应用场景有哪些？

除了基本的算法选择，编译期策略选择还可以用于更高级的场景，例如：

• 性能优化： 根据编译时已知的信息（例如 CPU 特性），选择不同的优化策略。例如，如果编译器检测到支持 AVX 指令集，则选择使用 AVX 指令集的优化版本；否则，选择使用 SSE 指令集的版本。
• 代码生成： 根据编译时配置，生成不同的代码。例如，可以根据编译时定义的宏，选择是否包含调试代码，或者选择使用不同的数据结构实现。
• 安全策略： 根据编译时的安全配置，选择不同的安全策略。例如，可以根据编译时定义的权限级别，选择是否启用某些安全检查。

这些应用场景都需要更复杂的模板元编程技巧，例如使用

std::enable_if

如何在运行时动态切换策略，同时尽量减少性能损失？

虽然我们讨论的是编译期多态，但有时候需要在运行时动态切换策略。一个折衷方案是使用函数指针或者

std::function

#include 
#include 

template 
void strategyA(T& data) {
    std::cout << "StrategyA executing with data: " << data << std::endl;
    data += 1;
}

template 
void strategyB(T& data) {
    std::cout << "StrategyB executing with data: " << data << std::endl;
    data *= 2;
}

template 
class Context {
public:
    using StrategyFunc = std::function;

    Context(StrategyFunc strategy) : strategy(strategy) {}

    void processData(T& data) {
        strategy(data);
    }

    void setStrategy(StrategyFunc newStrategy) {
        strategy = newStrategy;
    }

private:
    StrategyFunc strategy;
};

int main() {
    int data = 5;
    Context context(strategyA); // 初始策略为 strategyA
    context.processData(data); // 输出 "StrategyA executing with data: 5"， data变为6

    context.setStrategy(strategyB); // 动态切换到 strategyB
    context.processData(data); // 输出 "StrategyB executing with data: 6"， data变为12

    return 0;
}

虽然这引入了函数调用的开销，但避免了虚函数调用的开销。对于一些对性能要求不是特别高的场景，这是一个可以接受的方案。 另一种方式是使用跳转表（Jump Table），预先将所有可能的策略地址存储在一个数组中，然后根据索引来选择执行哪个策略。这可以减少动态查找策略的开销，但需要提前知道所有可能的策略。