模板策略模式通过编译期多态在编译时确定策略，避免虚函数调用开销，提升性能；使用类型擦除可减少代码膨胀，而运行时动态切换策略可通过函数指针或跳转表实现，在灵活性与性能间取得平衡。
模板策略模式，本质上是为了解决算法族中，核心流程固定但具体步骤可变的问题。编译期多态方案，则是在编译时确定具体使用哪个策略，避免运行时的虚函数调用开销，提高性能。
解决方案
模板策略模式的核心在于定义一个模板方法，这个方法定义了算法的骨架，而将一些步骤延迟到子类去实现。编译期多态，意味着我们希望在编译时就确定使用哪个子类（策略）。这通常可以通过模板元编程来实现。
#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类现在只需要一个模板参数
T，而策略的选择在构造
AnyStrategy对象时完成。
编译期策略选择的更高级应用场景有哪些？
除了基本的算法选择，编译期策略选择还可以用于更高级的场景，例如：
- 性能优化： 根据编译时已知的信息（例如 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），预先将所有可能的策略地址存储在一个数组中，然后根据索引来选择执行哪个策略。这可以减少动态查找策略的开销，但需要提前知道所有可能的策略。
