C++11 Aspect自实现

已于 2022-04-20 11:38:11 修改
阅读量1.6k 收藏 2
点赞数
分类专栏： C\C++ 文章标签： c++
于 2022-04-20 10:01:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43862847/article/details/124287771
版权

想加个类似spring里面的AOP，避免插桩式的编码，也方便代码复用。

虽然有AspectC++这个现成的轮子，但是看下了下也是静态的，根据AspectC++对应的语法使用自己的编译器编译的时候替换成C++代码语法，不是我想要的，引入是个麻烦事。

那就只能自己造了，写了一点，写的不怎么满意，只能说先凑活用，做不到JAVA那么灵活，先记录下来吧，后面有精力看看怎么完善吧。

以下只对C++11，如果有C++17，可以用 if constexpr 去掉下面重复的模板函数匹配，一坨参数匹配，写着难受看着难受。

/*
 * @Author: shanRX
 * @Date: 2022-02-24 15:23:06
 * @LastEditTime: 2022-02-28 10:01:00
 * @LastEditors: shanRX
 * @Description: 切面编织
 * 咸鱼本咸
 */

#include <functional>
#include <list>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>

template <typename T, typename... Args>
class HasAfterFunc {
    template <typename C = T>
    static auto test(int) -> decltype(std::declval<C>().after(std::declval<Args>()...), std::true_type());
    template <typename C = T>
    static std::false_type test(...);

public:
    enum {
        value = std::is_same<decltype(test(0)),
            std::true_type>::value
    };
};

template <typename T, typename... Args>
class HasBeforeFunc {
    template <typename C = T>
    static auto test(int) -> decltype(std::declval<C>().before(std::declval<Args>()...), std::true_type());
    template <typename C = T>
    static std::false_type test(...);

public:
    enum {
        value = std::is_same<decltype(test(0)),
            std::true_type>::value
    };
};


template<typename... Args>
class AspectWeaver
{
  public:
    template <typename AspectType>
    typename std::enable_if<std::is_class<AspectType>::value && HasBeforeFunc<AspectType, Args...>::value && !HasAfterFunc<AspectType, Args...>::value>::type
    addAspect(std::shared_ptr<AspectType> aspect)
    {

        m_beforeList.push_back([aspect](Args &&...args) { aspect->before(std::forward<Args>(args)...); });
    }

    template <typename AspectType>
    typename std::enable_if<std::is_class<AspectType>::value && HasBeforeFunc<AspectType, Args...>::value &&
                            HasAfterFunc<AspectType, Args...>::value>::type
    addAspect(std::shared_ptr<AspectType> aspect)
    {
        m_beforeList.push_back([aspect](Args &&...args) { aspect->before(std::forward<Args>(args)...); });
        m_afterList.push_front([aspect](Args &&...args) { aspect->after(std::forward<Args>(args)...); });
    }

    template <typename AspectType>
    typename std::enable_if<std::is_class<AspectType>::value && HasAfterFunc<AspectType, Args...>::value && !HasBeforeFunc<AspectType, Args...>::value >::type
    addAspect(std::shared_ptr<AspectType> aspect)
    {
        m_afterList.push_front([aspect](Args &&...args) { aspect->after(std::forward<Args>(args)...); });
    }

    template <typename FuncType>
    auto invoke(FuncType &&func, Args... args) -> decltype(std::declval<FuncType>()(args...))
    {
        for (auto iter : m_beforeList)
        {
            iter(args...);
        }
        auto r = func(args...);
        for (auto iter : m_afterList)
        {
            iter(args...);
        }
        return r;
    }

    private:
    std::list<std::function<void(Args...)>> m_beforeList;
    std::list<std::function<void(Args...)>> m_afterList;
};

#include <iostream>
class MyClass {
public:
    int func(int i)
    {
        i = i*i;
        std::cout << i << std::endl;
        return 0;
    }

    int func1(int i)
    {
        i += 1;
        std::cout << "this func1 " << i << std::endl;
        return 0;
    }
};

class Aspect1 {
public:
    void before(int i)
    {
        std::cout << "Aspect1 before" << std::endl;
    }
};

class Aspect2 {
public:
    void after(int i)
    {
        std::cout << "Aspect2 after" << std::endl;
    }
};

class Aspect3 {
public:
    void before(int i)
    {
        std::cout << "Aspect3 begin" << std::endl;
    }

    void after(int i)
    {
        std::cout << "Aspect3 end" << std::endl;
    }
};

int main(){
    AspectWeaver<int> weaver;
    weaver.addAspect(std::make_shared<Aspect1>());
    weaver.addAspect(std::make_shared<Aspect2>());
    weaver.addAspect(std::make_shared<Aspect3>());

    MyClass a;
    weaver.invoke(std::bind(&MyClass::func, &a, std::placeholders::_1), 1);

    weaver.invoke([&a](int PH1) { return a.func1(std::forward<decltype(PH1)>(PH1)); }, 1);
}

输出

Aspect1 before
Aspect3 begin
1
Aspect3 end
Aspect2 after
Aspect1 before
Aspect3 begin
this func1 2
Aspect3 end
Aspect2 after

此外还有参考网上 另外一种更静态的实现

/*
 * @Author: shanRX
 * @Date: 2022-02-24 15:23:06
 * @LastEditTime: 2022-02-28 10:01:00
 * @LastEditors: shanRX
 * @Description: 切面编织
 * 咸鱼本咸
 */

#include <functional>
#include <list>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>

template <typename T, typename... Args>
class HasAfterFunc {
    template <typename C = T>
    static auto test(int) -> decltype(std::declval<C>().after(std::declval<Args>()...), std::true_type());
    template <typename C = T>
    static std::false_type test(...);

public:
    enum {
        value = std::is_same<decltype(test(0)),
            std::true_type>::value
    };
};

template <typename T, typename... Args>
class HasBeforeFunc {
    template <typename C = T>
    static auto test(int) -> decltype(std::declval<C>().before(std::declval<Args>()...), std::true_type());
    template <typename C = T>
    static std::false_type test(...);

public:
    enum {
        value = std::is_same<decltype(test(0)),
            std::true_type>::value
    };
};

template <typename Func, typename... Args>
struct Aspect {
    Aspect(Func&& f)
        : m_func(std::forward<Func>(f))
    {
    }

    template <typename T>
    typename std::enable_if<HasBeforeFunc<T, Args...>::value && HasAfterFunc<T, Args...>::value>::type Invoke(Args&&... args, T&& aspect)
    {
        aspect.before(std::forward<Args>(args)...); //核心逻辑之前的切面逻辑
        m_func(std::forward<Args>(args)...); //核心逻辑
        aspect.after(std::forward<Args>(args)...); //核心逻辑之后的切面逻辑
    }

    template <typename T>
    typename std::enable_if<HasBeforeFunc<T, Args...>::value && !HasAfterFunc<T, Args...>::value>::type Invoke(Args&&... args, T&& aspect)
    {
        aspect.before(std::forward<Args>(args)...); //核心逻辑之前的切面逻辑
        m_func(std::forward<Args>(args)...); //核心逻辑
    }

    template <typename T>
    typename std::enable_if<!HasBeforeFunc<T, Args...>::value && HasAfterFunc<T, Args...>::value>::type Invoke(Args&&... args, T&& aspect)
    {
        m_func(std::forward<Args>(args)...); //核心逻辑
        aspect.after(std::forward<Args>(args)...); //核心逻辑之后的切面逻辑
    }

    template <typename Head, typename... Tail>
    typename std::enable_if<HasBeforeFunc<Head, Args...>::value && HasAfterFunc<Head, Args...>::value>::type Invoke(Args&&... args, Head&& headAspect, Tail&&... tailAspect)
    {

        headAspect.before(std::forward<Args>(args)...);
        Invoke(std::forward<Args>(args)..., std::forward<Tail>(tailAspect)...);
        headAspect.after(std::forward<Args>(args)...);
    }

    template <typename Head, typename... Tail>
    typename std::enable_if<!HasBeforeFunc<Head, Args...>::value && HasAfterFunc<Head, Args...>::value>::type Invoke(Args&&... args, Head&& headAspect, Tail&&... tailAspect)
    {

        Invoke(std::forward<Args>(args)..., std::forward<Tail>(tailAspect)...);
        headAspect.after(std::forward<Args>(args)...);
    }

    template <typename Head, typename... Tail>
    typename std::enable_if<HasBeforeFunc<Head, Args...>::value && !HasAfterFunc<Head, Args...>::value>::type Invoke(Args&&... args, Head&& headAspect, Tail&&... tailAspect)
    {
        headAspect.before(std::forward<Args>(args)...);
        Invoke(std::forward<Args>(args)..., std::forward<Tail>(tailAspect)...);
    }

private:
    Func m_func; //被织入的函数
};

template <typename T>
using identity_t = T;

// AOP的辅助函数，简化调用
template <typename... AP, typename... Args, typename Func>
void Invoke(Func&& f, Args&&... args)
{
    Aspect<Func, Args...> asp(std::forward<Func>(f));
    asp.Invoke(std::forward<Args>(args)..., identity_t<AP>()...);
}

#include <iostream>

class MyClass {
public:
    int func(int i)
    {
        i = i * i;
        std::cout << i << std::endl;
        return 0;
    }

    int func1(int i)
    {
        i += 1;
        std::cout << "this func1 " << i << std::endl;
        return 0;
    }
};

class Aspect1 {
public:
    void before(int i)
    {
        std::cout << "Aspect1 before" << std::endl;
    }
};

class Aspect2 {
public:
    void after(int i)
    {
        std::cout << "Aspect2 after" << std::endl;
    }
};

class Aspect3 {
public:
    void before(int i)
    {
        std::cout << "Aspect3 begin" << std::endl;
    }

    void after(int i)
    {
        std::cout << "Aspect3 end" << std::endl;
    }
};

int main()
{
    MyClass a;

    Invoke<Aspect1,Aspect2,Aspect3>(std::bind(&MyClass::func, &a, std::placeholders::_1), 1);
    Invoke<Aspect1,Aspect2,Aspect3>([&a](int PH1) { return a.func1(std::forward<decltype(PH1)>(PH1)); }, 1);
}

输出一致

Aspect1 before
Aspect3 begin
1
Aspect3 end
Aspect2 after
Aspect1 before
Aspect3 begin
this func1 2
Aspect3 end
Aspect2 after
无人等人
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Aspect C++语言
Carly学习笔记
04-07 5016
AOP的核心思想是对横切关注点进行模块化。Aspect C++是针对C++的AOP扩展。 join point：运行aspects的代码部分，可以使类、结构、联合、对象、控制流。 pointcut：是join point的集合。用来定义在什么地方插入advice代码，进行横向切入。类似于C++中的变量，只不过带个括号。定义格式如下：pointcut 变量名() = 标志符(
AspectC++ join point,pointcut,advice,aspect,slices, introduction
LU_ZHAO的博客
02-18 415
AOP的核心思想是对横切关注点进行模块化。Aspect C++是针对C++的AOP扩展。 join point：运行aspects的代码部分，可以使类、结构、联合、对象、控制流 execution join point与可执行函数名关联。纯虚函数不可执行，因此可执行join point的advice代码不能应用于纯虚函数。但纯虚函数的调用，即这类函数作为call join point，是可以的...
C++之AOP
头脑歪歪
12-15 558
AOP是近年炒得很热，但却用得很少的一门技术，不过这并不能阻止我去学习它。既然能一度炒得火热，必定有过人之处。说AOP是一种思想或许更适合一些，它并不描述哪一种专有的技术，也不指定实现方式。众所周知，C++没有丰富的动态类型信息，更没有动态生成类的功能(C++类型在编译后就基本上没有类型存在了)，所以无法像java一样采用动态代理来实现AOP。Aspect C++是C++的一个AOP实现，它...
AspectC++ 转换源码运行脚本
05-10
自行整理了一个运行AspectC++转换源码运行的shell脚本代码，只需修改aspectC++工具路径和第三方头文件路径；然后把该脚本放在工程源文件目录中运行即可。
C++11 简易线程池实现
03-15
简易的C++11线程池实现，线程池为固定方式，后面会新增非固定模式。
aspectC++编译器
05-22
aspectC++的编译器，解压后在“README.win32”文件中有使用说明！
AspectC++运行脚本
05-10
自行整理了一个运行AspectC++转换源码运行的shell脚本代码，只需修改aspectC++工具路径和第三方头文件路径；然后把该脚本放在工程源文件目录中运行即可。
aspectc++初级用法
goto2091的博客
09-07 1832
AspectC++用法 详细教程见 http://www.aspectc.org/doc/ac-languageref.xhtml 实例 example文件里, 有一个随机事件发生程序——SimpleEventLoop, aspectC++最适合的是插装事件日志 编译和使用 见AutoMonitor/lib/aspectC++/examples/ 里面编写的示例, acc的文件后缀名为.ah,本质是一种特殊的C++头文件。 ac++是编译AspectC++程序的编译器。 实现将AspectC++代码转化为C
C++11面向切面编程（AOP）入门指南
weixin_36623563的博客
04-05 1795
AOP的核心概念是切面（Aspect），它表示在程序中跨越多个功能模块的关注点。例如，日志记录、事务管理和权限控制等功能都可以视为切面。通过将这些关注点从业务逻辑中分离出来，实现对程序行为的模块化，从而提高代码的可读性和可维护性。关键词：关注点分离，核心逻辑和非核心逻辑分离，核心关注点和切面关注点。
C++ 公共组件-轻量级AOP库
wangdamingll的博客
03-11 1639
C++ 公共组件-轻量级AOP库 1.AOP介绍 AOP（Aspect-Oriented Programming，面向方面编程），可以解决面向对象编程中的一些问题，是OOP的一种有益补充。面向对象编程中的继承是一种从上而下的关系，不适合定义从左到右的横向关系，如果继承体系中的很多无关联的对象都有一些公共行为，这些公共行为可能分散在不同的组件、不同的对象之中，通过继承方式提取这些公共行为就不太合适了...
c++11线程池简单实现
12-05
该资源为c++11版本的线程池实现，其中调用了c++11相关的新特性，例如thread、function等，推荐新手下载使用！
基于C++11实现的定时器
11-18
分享一个基于C++11实现的定时器，当有多个定时任务时，向定时器里面添加定时任务，定时器到时间自动执行事件，编译环境(GCC) 4.7.2
C++11 线程池 ThreadPool
12-21
C++11 线程池 ThreadPool 单例 线程池，实现全局唯一。
C++11实现的跳表源码
06-15
C++11实现的跳表源码
aspect c++
02-05
aspect c++
vscode + clangd 开发 c\c++
热门推荐
无人等人的博客
08-01 2万+
目录标题背景发现clangd三级目录 背景 vscode c++开大家一般用 巨硬 自家出品的c++插件，如下 网络大部分的vcscode c++ 环境搭建也都是讲这个插件的配置，用于提供悬浮提示，代码补全，错误提示，定义声明实现之间的项目跳转等等功能。 我之前也是用这个插件开发，总体还好，至少比在我之前用的一些keil之类的IDE好用很多，但是和IDEA这种更现代化的IDEA有不小差距。 先不说导航找实现找引用这种语义分析的基本功能有时候都没办法正确找到实现，错误和警告也只是有提示，没有quick f
CMAKE 里PRIVATE、PUBLIC、INTERFACE属性示例详解
无人等人的博客
08-17 1万+
闲扯 cmake 里面target_include_directories，target_link_libraries这两个命令里面有三种属性PRIVATE、PUBLIC、INTERFACE。 cmake PRIVATE、PUBLIC、INTERFACE的讲解网络上很多，但是总觉得太过偏概念了，看完并没有让人有深入细节的了解。 于是动手做个示例，就有了本杂文。 这三种属性，从根本上来讲属于cmake里面传播特性的三种等级。 实例 既然传播特性，那么我们肯定需要多个target来演示传播。 testCMake
linux 程序crash 调试、原因分析及问题定位
无人等人的博客
05-26 6971
linux 程序崩溃，如果能根据已有的插桩日志能排查出来自然好，但是往往日志未全覆盖，这时候排查起来还是比较麻烦的。 一般来说有以下这几种方法获取崩溃现场数据。 core dump core dump是linux原生自带的一个异常分析工具，当程序运行的过程中异常终止或崩溃，操作系统会将程序当时的内存状态记录下来，保存在一个文件中。注意程序编译 需要带 -g。 开启core dump linux 默认是关闭的。 开启 ulimit -c unlimited 此时，运行程序发生sigsegv之类的异常时
vscode #ifdef编译开关关闭时不显示灰的问题
无人等人的博客
04-25 6111
敲着敲着不知道手贱碰哪了，突然关的的编译开关不显示灰了。 正常情况下 开： 关： 现在突然，所有预编译控制块全是活动状态。 网上说的，都是vscode #ifdef 区域变暗，跟我不是一个问题 最后发现是手贱点了这个配置的问题。 如果你不手贱不点编辑，默认是有一个值的，但是如果跟我一样纯手贱点了没细看选项就傻了，在settings.json会生成一个字段，并且默认值就被改成null，然后就没有非活动编译块暗色处理了，蛋疼。 “C_Cpp.inactiveRegionOpacity”: null,
C++实现Opengl透视投影
最新发布
11-21
以下是C++实现OpenGL透视投影的代码示例： ```cpp // 定义投影参数 float fovy = 70.0f; // y轴视角 float aspect = 1.0f; // 投影面的长宽比 float zNear = 0.1f; // 近截面 float zFar = 100.0f; // 远截面 // 计算投影矩阵 glm::mat4 projection = glm::perspective(glm::radians(fovy), aspect, zNear, zFar); // 将投影矩阵传递给着色器 unsigned int projectionLoc = glGetUniformLocation(shaderProgram, "projection"); glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection)); ``` 上述代码中，我们首先定义了投影参数，包括y轴视角、投影面的长宽比、近截面和远截面。然后，我们使用GLM库中的`glm::perspective`函数计算投影矩阵。最后，我们将投影矩阵传递给着色器，以便进行渲染。 需要注意的是，我们使用了GLM库中的`glm::value_ptr`函数将投影矩阵转换为指针类型，以便在OpenGL中使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值