C++实现简单的AOP面向切面编程 _ 模板封装与函数包装器【源码】-C++-PHP中文网

C++无原生AOP，但可用std::function+可变参数模板实现编译期函数包装：通过AspectWrapper封装调用前后逻辑，支持完美转发、异常安全与类型推导，兼顾灵活性与性能权衡。

c++实现简单的aop面向切面编程 _ 模板封装与函数包装器【源码】

为什么 C++ 没有原生 AOP，但 `std::function` + 模板能凑出可用的切面逻辑

C++ 标准库不提供类似 Spring AOP 或 AspectJ 的织入机制，也没有运行时方法拦截能力。所谓“C++ AOP”，本质是**编译期函数包装**：在调用目标函数前/后，手动插入横切逻辑（如日志、计时、权限检查）。关键不是模拟 Java 风格的注解和代理，而是用 std::function 封装可调用对象，再用模板统一处理签名，避免为每个函数类型写重复包装代码。

容易踩的坑：
- 直接用宏或裸函数指针包装会丢失参数绑定和移动语义
- 忽略 const/volatile 重载或右值引用参数，导致模板推导失败
- 把切面逻辑硬编码进包装器，失去复用性

用可变参数模板 + `std::forward` 实现通用包装器

核心是让一个包装器能适配任意返回类型、任意参数个数和类型的函数对象。不能靠重载枚举所有组合，必须用参数包展开。

包装器构造时接收原始函数（Callable）和前置/后置操作（std::function 或更泛化的可调用对象）
调用 operator() 时，用 std::forward(args)... 完美转发参数，保留左值/右值属性
前置操作应在目标函数调用前执行，后置操作在 try/catch 后执行（防止异常绕过清理）

template<typename callable typename before after>
class AspectWrapper {
    Callable func_;
    Before before_;
    After after_;
<p>public:
AspectWrapper(Callable f, Before b, After a) 
: func<em>(std::move(f)), before</em>(std::move(b)), after_(std::move(a)) {}</p>
<pre class="brush:php;toolbar:false;">template<typename... args>
auto operator()(Args&&... args) 
    -> decltype(func_(std::forward<args>(args)...)) {
    before_();
    try {
        auto result = func_(std::forward<args>(args)...);
        after_();
        return result;
    } catch (...) {
        after_(); // 异常时也执行后置（如资源释放）
        throw;
    }
}</args></args></typename...>

};

`std::function` 包装器的性能代价与替代方案

用 std::function 存储前置/后置逻辑，方便传入 lambda 或普通函数，但带来两次间接调用开销（虚函数表跳转），且无法内联。对高频调用函数（如数学计算密集型），这可能成为瓶颈。

C++14

C++14 对 C++11 的修正与增强版本，适合旧系统维护和较老工具链兼容。

下载

若切面逻辑固定（如只做计时），可将 Before/After 设为模板非类型参数，让编译器内联
若需运行时切换行为（如开关日志），std::function 是合理选择，但应避免在 tight loop 中使用
注意 std::function 构造成本：捕获大对象的 lambda 可能触发堆分配，优先用值捕获小对象或引用捕获

实际封装示例：带计时和日志的函数包装

真实场景中，你不会每次都手写 AspectWrapper 实例。应提供工厂函数，隐藏模板细节。

template<typename callable typename logger>
auto make_timed_logger_wrapper(Callable&& f, Logger&& logger) {
    auto before = [logger = std::forward<logger>(logger)]() {
        logger("start");
    };
    auto after = [logger = std::forward<logger>(logger)]() {
        logger("end");
    };
    return AspectWrapper{
        std::forward<callable>(f),
        std::move(before),
        std::move(after)
    };
}
<p>// 使用
auto wrapped = make_timed_logger_wrapper(
[](int x) { return x <em> x; },
[](const char</em> msg) { std::cout </p></callable></logger></logger></typename>

注意：lambda 捕获 logger 时用了移动语义，避免拷贝；工厂函数本身也用了完美转发，确保 Callable 和 Logger 的值类别不被破坏。

最易被忽略的一点：切面逻辑里如果抛异常，而原始函数也抛异常，after_() 在第一个 catch 里执行完后会再次 throw，此时栈已开始展开——务必保证 after_ 是无异常规范（noexcept）的，否则程序直接终止。