经典策略模式在 C++ 史上地位显赫，它用虚函数帮我们实现了运行时多态下的算法替换。

但因为模板元编程的成熟。有人就会想：既然很多策略编译期就能定死，为什么还要忍受间接跳转和内联屏障？于是编译期策略模式登场了。

运行时策略模式的利与弊

使用者痛点：在高频业务方法上。每一次虚函数调用都会带来一次间接跳转导致 CPU 分支预测失效、指令缓存失效，进而出现明显的性能回退；虚函数无法被内联，使得本可以在热循环中消除的计算被迫保留。

我们先写个运行时策略模式，回忆一下那种万物皆对象的舒适感。

假设我们有一个简单的文本处理上下文。它需要把一段文本转换成大写或小写，运行时随便换策略。

// 经典策略接口
class ITextStrategy{
public这方面，virtual std::string transform const = 0;怎么说呢，virtual ~ITextStrategy = default;}，// 大写策略
class UpperStrategy : public ITextStrategy{
说到public。std::string transform const override{
至于std:，string result = text;for c = toupper;return result;}
}，// 小写策略
class LowerStrategy : public ITextStrategy{
再看public。std::string transform const override{
至于std:，string result = text;for c = tolower;return result;}
}，// 组合策略
class TextProcessor{
说到std:，unique_ptr strategy_;public:
explicit TextProcessor : strategy_) {}
void setStrategy{ strategy_ = std::move;}
std:这方面，string process const{
return strategy_->transform;}
}，// 使用示例
int main{
TextProcessor proc);auto result1 = proc.process;// "HELLO WORLD"
proc.setStrategy);auto result2 = proc.process;// "hello world"
}

这设计多棒啊，多态替换、开闭原则、单一职责。想加新策略，再写个类，顶多改改工厂，主要业务逻辑纹丝不动，单元测试也轻松。在业务代码里这种灵活度确实舒服。

使用者痛点：只是每一次 strategy_->transform 都要经历以下步骤：

• 从对象的 vptr 中取出虚表地址；
• 根据偏移量算出函数指针；
• 通过该指针进行间接跳转。

更关键的是：编译器根本无法对 transform 进行内联。因为它不知道运行时到底会是哪一个子类，只能生成一次统一的 call 指令。于是高频方法上的微小开销会被放大成可观的性能瓶颈。不过，

运行时的策略模式就是这么一个让人又爱又恨的东西：它给了我们架构上的体面却可能在高频执行的方法上把性能底裤扯得稀烂。这就是为什么需要编译期策略模式。

初识编译期策略

. 模板模板参数初试

使用者痛点：#1 —— “我已经确定业务逻辑不会在运行时切换，但仍然被迫使用虚函数”。#2 —— “我想在热循环里直接看到 SIMD‑friendly 的展开代码”。

主要思想很简单：把策略本身做成类模板，把它当作模板参数传给宿主模板。宿主在实例化阶段就能“看到”具体的实现，从而完成完整内联。

// 转大写
struct UpperPolicy{
static char transform{
return?c - : c，}
};// 转小写
struct LowerPolicy{
static char transform{
return?c + : c，}
};// 接受一个策略类型作为模板参数
template 
class TextProcessor{
至于public，void process const{
for {
c = TransPolicy::transform;}
}
}，不过，// 使用示例
TextProcessor upperProc;TextProcessor lowerProc;std::string txt = "Hello World";按理说，upperProc.process;// 直接内联
lowerProc.process;

编译器在实例化 TextProcessor 时会把循环里的 TransPolicy::transform` 完全展开为三元运算符，从而消除所有函数调用开销。说起来，

. 策略的

使用者痛点：#3 —— “业务需求变化。需要为同一套框架注入前缀/后缀、字符集等额外信息”。如果仍然使用运行时多态，就必须为每一种组合维护大量派生类或繁琐的工厂代码。

C++ 编译期策略天然支持把任意编译期常量塞进类型内部：静态方法、成员别名、constexpr 常量…，宿主模板只要使用 T::xxx` 或 T::value` 即可，无需任何改动。

//
策略
struct UpperPolicy{
static char transform{
return?c - : c，}
static const char* prefix{ return "> ";}
static const char* suffix{ return " <"; }
    using char_type = char;
};
template 
class TextProcessor{
public这方面。void process const{
从std:来看，string result;result += Policy::prefix;for {
result += Policy::transform;}
result += Policy::suffix;text.swap，}
};

. 模板方法 + 策略

使用者痛点：#4 —— “我想保留‘算法骨架’不变，但不同业务场景需要细节实现”。传统模板方法依赖虚函数，而这里可以用编译期策略完全去掉虚函数。 实现零开销的骨架+细节分离。

struct Data{ /* ... */ };struct Record{ /* ... */ };template 
class Exporter{
public这方面，void exportData const{
ExportPolicy::validate;os < ExportPolicy::formatHeader;
        for {
            os < ExportPolicy::formatRecord;
        }
        os < ExportPolicy::formatFooter;
    }
};
struct CsvPolicy{
    static void validate {}
    static std::string formatHeader{ return "id,name
"; }
    static std::string formatRecord{
        return std::to_string + "," + r.name + "
";
}
cpp
// 使用方式
ExporterCsvPolicy csvExp;

. CRTP 的引入

User Pain Point #5: The indirection of virtual calls not only hurts performance but also obscures call graph。making debugging and profiling harder.
template 
class Buffer{
至于public，void write{
static_cast->writeImpl;}
}，class FileBuffer : public BufferFileBuffer{
从public来看，void writeImpl{ /* 写文件 */ }
};class NetworkBuffer : public BufferNetworkBuffer{
public的观点是，void writeImpl{ /* 发送网络包 */ }
};

The CRTP pattern is essentially a compile‑time injection of a strategy: base class provides a stable skeleton while derived class supplies concrete step via a static cast. This eliminates any v‑table lookup and gives compiler full visibility for inlining.

C++ Concepts 定义策略契约

. Concepts 登场

User Pain Point #6: SFINAE‑based checks are cryptic and produce waterfall error messages that hide real problem.
#include 
template 
concept TransPolicy = requires{
{ T::transform } ->;// 必须返回 char
{ T::prefix } ->;按理说，// 必须返回 const char*
{ T::suffix } ->;}，

The concept replaces loose “typename” requirement with a clear contract. If a type fails to meet it,compiler tells you exactly which member is missing.
template TransPolicy
class TextProcessor{/* 同前实现 */};

. Concepts 约束下的策略适配

User Pain Point #7: I have legacy classes that don’t follow my new concept – rewriting m is risky.
struct LegacyLower{
static char convert{ return?c + : c，}
static const char* prefix{ return "";}
}，// Adapter使其符合TransPolicy
struct LegacyLowerAdapter{
static char transform{ return LegacyLower::convert;}
static const char* prefix{ return LegacyLower::prefix;}
static const char* suffix{ return LegacyLower::suffix;}
}，怎么说呢，using MyLogger = TextProcessorLegacyLowerAdapter;

If many legacy policies exist,a generic adapter can be built with partial specialization:
template 
struct PolicyAdapter{ using type=P;}，template 
requires
&& requires{ {P::} ->;}
struct PolicyAdapter{
struct type: P {
static char transform{return P::;}
}，};template 
using Adapted_t = typename PolicyAdapter

::type;template 
class TextProcessor{/* 同前实现，只是使用 Adapted_t

};不过，




建立一个编译期可定制的日志记录器 

. 设计思路 


User Pain Point #8: I want zero‑overhead logging in release builds while still having rich configurability during development.

The decision wher to log,where to write。and how to format should be made at compile time.

This eliminates both virtual dispatch and dead code that would orwise be stripped only by optimizer.


. 策略维度 


: decides minimal log level and provides string label.

Sink policy>: handles actual output – console,file or null sink.

Format policy>: builds message prefix .


. Concept 契约 
enum class Level{ Debug,Info,Warning,Error };// Level policy
template 
concept LevelPolicy =
requires{
至于{T:，} ->;// constexpr Level
{T:这方面，} ->;// 返回 string_view
};// Sink policy
template 
concept SinkPolicy =
requires{
{s.} ->;// void
{s.} ->;// void
}，// Format policy
template 
concept FormatPolicy =
requires{
{T:的观点是，} ->;// returns string
};/// Logger 实现 -----------------------------------------------------------
template <
     LevelPolicy LP,
     SinkPolicy SP,
     FormatPolicy FP
    >
class Logger{
至于public，explicit Logger:sink_){};其实，
 template <
     Level L>
void log{
if constexpr)
return;// 编译期剔除
auto formatted=FP::,msg);sink_.write，不过，sink_.flush;}
// 简易包装 -----------------------------------------------------
void debug{log<::Debug>;}
void info {log<::Info>;}
void warn {log<::Warning>;}
void error{log<::Error>;}


private:
SP sink_;}，

/// 示例政策 -----------------------------------------------------------
// ConsoleSink
struct ConsoleSink{
void write{
fwrite。1,msg.size,stderr);fputs，}
void flush{ fflush;}
}，

// NullSink
struct NullSink{
void write {}
void flush {}
};

// 时间戳格式化器
struct TsFormatter{
static string format{
auto now=chrono::.systemclock::.now;auto tt=chrono::.systemclock::.totimet;string ts=ctime;ts.pop_back，// 去掉换行符
return ts+" "+ string;}
}，

// 默认级别
struct DefLvl{
static constexpr Level minimumlevel=Level ::Debug;static stringview tostring{
using namespace stringviewliterals;switch{
case Level ::Debug: return "DEBUG"sv;case Level ::Info: return "INFO"sv;case Level ::Warning: return "WARN"sv;case Level ::Error: return "ERROR"sv;}
return "，?，"sv;}
}，// 发布版仅保留 Warning+
struct RelLvl:DefLvl{
static constexpr Level minimumlevel=Level ::Warning;}，

// -------------------------------------------------------------------
// 使用示例
int main{
using DevLog=Logger<&DefLvl,&ConsoleSink,&TsFormatter>;DevLog dev)，dev.debug;话说回来，dev.warn;
 using ProdLog=Logger<&RelLvl,&NullSink,&TsFormatter>;ProdLog prod);prod.debug，// 被编译剔除
prod.error;// 虽然输出为空，但仍走完整流程。可由 NullSink 决定是否真的无操作。

}




User Pain Point #9: I don't want to replace virtual functions everywhere—only where y become a measurable bottleneck.

The classic runtime strategy pattern remains invaluable when true runtime configurability is required or when code readability outweighs micro‑optimizations. Compile‑time strategies are not meant to “kill” virtual functions wholesale but rar give us an extra tool for those hot paths where every cycle counts.