模板策略模式怎么实现编译期多态方案-C++-PHP中文网

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

P粉602998670

发布： 2025-08-20 11:00:02

原创

317人浏览过

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

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

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

解决方案

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

#include <iostream>
#include <type_traits>

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

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

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

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

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

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

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

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

登录后复制

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

Context

登录后复制

类接受一个策略类型作为模板参数，并在构造函数中实例化该策略。这样，策略的选择就在编译时完成了。

如何避免代码膨胀？

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

Context

登录后复制

类。解决办法之一是使用类型擦除（Type Erasure）。类型擦除允许你使用一个通用的接口来处理不同类型的对象，而不需要在编译时知道这些对象的具体类型。

#include <iostream>
#include <functional>

template <typename T>
class AnyStrategy {
public:
    using ExecuteFunc = std::function<void(T&)>;

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

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

private:
    ExecuteFunc executeFunc;
};

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

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

template <typename T>
class Context {
public:
    Context(AnyStrategy<T> strategy) : strategy(strategy) {}

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

private:
    AnyStrategy<T> strategy;
};

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

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

登录后复制

这里

AnyStrategy

登录后复制

使用

std::function

登录后复制

来存储策略的执行函数，从而实现了类型擦除。

Context

登录后复制

类现在只需要一个模板参数

登录后复制

，而策略的选择在构造

AnyStrategy

登录后复制

对象时完成。

AiPPT模板广场

AiPPT模板广场-PPT模板-word文档模板-excel表格模板

147

查看详情

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

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

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

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

std::enable_if

登录后复制

来根据编译时条件选择不同的代码路径。

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

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

std::function

登录后复制

。

#include <iostream>
#include <functional>

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

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

template <typename T>
class Context {
public:
    using StrategyFunc = std::function<void(T&)>;

    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<int> context(strategyA<int>); // 初始策略为 strategyA
    context.processData(data); // 输出 "StrategyA executing with data: 5"， data变为6

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

    return 0;
}

登录后复制

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

以上就是模板策略模式怎么实现编译期多态方案的详细内容，更多请关注php中文网其它相关文章！