cpp11利用宏、模板以及lambda表达式实现python like的装饰器语义（更新）

已于 2024-04-25 18:46:13 修改
阅读量316 收藏 2
点赞数 5
分类专栏： 轮子 文章标签： c++ 开发语言
于 2024-04-05 18:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43698957/article/details/137388756
版权

【CPP】【函数装饰器宏】cpp11利用宏、模板以及lambda表达式实现python like的装饰器语义

前言

python函数的装饰器是一个轻量级的函数功能拓展和复用工具，相比传统的派生重写虚函数的方式来说，避免了继承带来的耦合负担，控制也相对更加的简单，但cpp并没有相关的原生关键字支持，我参考了一些知乎和CSDN上的文章，但始终没有达到我想要的效果于是准备自己也动动手。
cpp11的lambda表达式提供了最基本的特性，基于此特性，我实现了类似语义的宏，跟python的函数装饰器相比创建形式并不相同，但是功能是相似的。
我事先在CSDN上发了一版，这一版是更新优化后的版本，装饰语法更加简洁，并且提供了cpp11兼容void返回值的解决方案。

用法

style1

int CCar::oilfeed(int degress)
DECORATE(logging,,
DECORATE(novoid,ARGS(),//对于装饰器的使用来说，如果没有参数，那么需要一个ARGS()占位或留空，留空看上去就是两个连续的','
DECORATE(maybe_void,,
//使用UNDECORATE宏可以单点禁用一个装饰器，原理是去掉了该层的 [&](){}包装器并悬空checkRotateSpeed以及ARGS里面的东西只保留代码块
UNDECORATE(checkRotateSpeed, ARGS(this, __FUNCTION__), //传递多个参数
{
    m_n_rotat_speed += degress;
    return m_n_rotat_speed;
})))) //用了多少个装饰器后面就要多少个),没办法cpp只能这样了，想不出更好的办法，本质是宏嵌套

style2

void CCar::brake(int degress)
DECORATE(logging, ARGS(__FUNCTION__),
//DECORATE(novoid,ARGS(), 使用novoid装饰器无法直接通过编译，因为不支持 void 作为返回值的偏特化
DECORATE(maybe_void,,
//推荐用仿函数的方式实现装饰器，通过构造函数传参封装性更好,如果舍弃函数类型的装饰器的话，就可以少一个宏参数占位了不用打奇怪的两个逗号了，
DECORATE(CheckRotateSpeed(this, __FUNCTION__),,
{
    m_n_rotat_speed -= degress;
})))

msvc2015 x64执行结果

完整测试代码

decorator.h

#ifndef DECORATOR_H
#define DECORATOR_H
#include <functional>


template<bool T>
//!
//! \brief The bool_trait struct
//! \usecase bool_trait<静态表达式->bool> 用于模拟模板偏特化
//!
struct bool_trait{};

template <typename T>
class func_caller final
{
public:
    using return_type = typename std::result_of<T&()>::type;
    using void_trait = bool_trait<std::is_same_v<void, return_type>>;

    explicit func_caller(T const &func)
        : stack(nullptr)
    {
        init(void_trait());
        call(func, void_trait());
    }

    ~func_caller()
    {
        release(void_trait());
    }

    return_type ret() const
    {
        return ret(void_trait());
    }

private:

    void* operator new(std::size_t) = delete;

    func_caller(func_caller const &) = delete;

    func_caller& operator=(func_caller const &) = delete;

    void init(bool_trait<true> const&)
    {
    }

    void init(bool_trait<false> const&)
    {
        stack = new return_type;
    }

    void release(bool_trait<true> const&)
    {

    }

    void release(bool_trait<false> const&)
    {
         delete stack;
    }

    void call(T &func, bool_trait<true> const&)
    {
        func();
    }

    void call(T const &func, bool_trait<false> const&)
    {
        *stack = std::move(func());//尽量调用移动构造函数
    }

    void ret(bool_trait<true> const&) const
    {

    }

    return_type ret(bool_trait<false> const&) const
    {
        return *stack;
    }

    return_type* stack;
};

//打包参数的宏，仿函数装饰器可以不使用
#define ARGS(...)\
    ,__VA_ARGS__

//启用装饰器语义宏定义
#ifndef NO_DECORATOR

//装饰宏，其实就是用 [&](){}把代码块包起来
#define DECORATE(decorator, args, codeblock) \
{\
    return decorator( [&]() codeblock args);\
    }
//单独禁用某个装饰器
#define UNDECORATE(decorator, args, codeblock) \
    codeblock
#else

//禁用所有装饰器
#define DECORATE(decorator, args, codeblock) \
    codeblock
#define UNDECORATE(decorator, args, codeblock) \
    codeblock
#endif // NO_DECORATOR

//隐藏模板语义，定义一个装饰器模板函数
#define DEF_DECIRATOR(name, .../*args*/) \
    template <typename T>\
    auto name(T const &func, __VA_ARGS__)

//实现临时快速禁用一个装饰器模板函数的功能，修改原装饰器为直接回调，然后将原本的逻辑添加到一个起始参数为void*的同名函数里面
#define DIS_DECIRATOR(name, .../*args*/) \
    template <typename T>\
    auto name(T const &func, __VA_ARGS__) \
    { return func(); }\
    template <typename T>\
    auto name(void *, T const &func, __VA_ARGS__)

//简化func_caller的使用方法
#define CALL() \
    func_caller<decltype(func)>(func)

#endif // DECORATOR_H

rm_decorator.h

#ifndef RM_DECORATOR_H
#define RM_DECORATOR_H

//禁用所有装饰器相关宏
#undef ARGS
#undef DECORATE
#undef UNDECORATE
#undef CALL
#undef DEF_DECIRATOR
#undef DIS_DECIRATOR
#endif // RM_DECORATOR_H

main.cpp

#include <functional>
#include <iostream>
#include <chrono>
#include <string>
//#define NO_DECORATOR
#include "base/decorator.h"
class CCar{
public:
    explicit CCar(){

    }

    int oilfeed(int degress);

    void brake(int degress);
    int rotat_speed() const {return m_n_rotat_speed;}
private:
    int m_n_rotat_speed = 2000;
};

/**
 * 注：此装饰器原理实为创建引用捕获的lambda表达式并调用，所以性能肯定会有所下降，但是增加了可读性，减少了维护难度
**/

//用原汁原味的写法定义装饰器函数，但是不能用过宏快速禁用，因为快速禁用实际是用重载实现的，所以只能增加代码分支进行控制如下面的写法
template <typename T>
auto checkRotateSpeed(T const &func/*第一个参数必须为函数*/, CCar const *obj, std::string const &funcname)
{
#if 1
    std::cout << "checkRotateSpeed before " << funcname  << ", rotat_speed:" << obj->rotat_speed()  << std::endl;
    auto const &caller = func_caller<decltype(func)>(func);//用func_caller模板来处理返回值为void的情况，缺点是非void返回值会多一些内存拷贝，所以条件允许的话对于大对象尽量使用智能指针作为返回值
    std::cout << "checkRotateSpeed after "  << funcname  << ", rotat_speed:" << obj->rotat_speed() << std::endl;
    return caller.ret();
#else
    return func();
#endif
}

//如果不用考虑返回值为 void，装饰器函数直接这么写就可以了，即简单性能又好
template <typename T>
auto novoid(T const &func)
{
    std::cout << "novoid before " << std::endl;
    auto const &ret = func();//直接调用被包装的函数获取结果，不用再返回一个包装器了是多此一举，包装器我是用装饰宏 DECORATE 封装了 [&]() 语句实现的，从这点看比python要简洁
    std::cout << "novoid after " << std::endl;
    return ret;
}

DEF_DECIRATOR //用宏语义快速定义装饰器函数
//DIS_DECIRATOR //快速禁用装饰器函数，原理为自动替换实现为 return func();
(logging, std::string const &funcname = "unknow func", int others = 0)
{
    (void) others;
    //在调用被装饰函数之前的操作
    std::cout <<"log before " << funcname  << std::endl;
    auto start = std::chrono::high_resolution_clock::now();
    auto const &caller = CALL();//使用CALL宏精简代码 func_caller<decltype(func)>(func)
    auto const &end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> time_span = std::chrono::duration_cast<std::chrono::duration<double>>(end - start);
    std::cout << "log after " << funcname << ": elapsed time(s): " << time_span.count() << std::endl;
    return caller.ret();
}

//兼容 void 返回值，不用 func_caller 的高性能的写法，考虑兼容c++11的话缺点是要把实现拷贝一份，有代码冗余不好维护，而且比较复杂要用一些奇技淫巧
//如果您的环境是c++17就不用看这个 maybe_void 了，直接用if constexpr吧
template<typename T>
auto maybe_void(T const &func)
{
    using ReturnType = typename std::result_of<T&()>::type;
    using IsVoidReturn = bool_trait<std::is_same_v<void, ReturnType>>;
    return maybe_void(func, IsVoidReturn());
}

using ReturnIsVoid = bool_trait<true>;
using ReturnIsntVoid = bool_trait<false>;

// 对于非void返回值的重载
template<typename T>
auto maybe_void(T const &func, ReturnIsntVoid const &)
{
    std::cout << "maybe_void before " << std::endl;
    auto const &ret = func();
    std::cout << "maybe_void after " << std::endl;
    return ret;
}

// 对于void返回值的重载
template<typename T>
void maybe_void(T const &func, ReturnIsVoid const &)
{
    std::cout << "maybe_void before " << std::endl;
    func();
    std::cout << "maybe_void after " << std::endl;
}

//定义一个仿函数装饰器，无论是函数装饰器还是仿函数装饰器，第一个参数都得是std::function<T ()> 类型否则装饰器宏无法正常展开
class CheckRotateSpeed
{
public:
    CheckRotateSpeed(CCar const *obj, std::string const &funcname)
        :m_p_obj(obj)
        ,m_str_funcname(funcname)
    {

    }

    //仿函数同样适用快速定义或禁用宏，模板的风格请参考 novoid 和 novoid_
    DEF_DECIRATOR
    //DIS_DECIRATOR
    (operator ())
    {
        //在调用被装饰函数之前的操作
        std::cout << "checkRotateSpeed before " << m_str_funcname  << ", rotat_speed:"<< m_p_obj->rotat_speed()  << std::endl;
        auto const &caller = CALL();
        //在调用被装饰函数之前的操作
        std::cout << "checkRotateSpeed after " << m_str_funcname  << ", rotat_speed:"<< m_p_obj->rotat_speed()  << std::endl;
        return caller.ret();
    }

private:

    CCar const *m_p_obj;
    std::string m_str_funcname;
};


int CCar::oilfeed(int degress)
DECORATE(logging,,
DECORATE(novoid,ARGS(),//对于装饰器的使用来说，如果没有参数，那么需要一个ARGS()占位或留空，留空看上去就是两个连续的','
DECORATE(maybe_void,,
//使用UNDECORATE宏可以单点禁用一个装饰器，原理是去掉了该层的 [&](){}包装器并悬空checkRotateSpeed以及ARGS里面的东西只保留代码块
UNDECORATE(checkRotateSpeed, ARGS(this, __FUNCTION__), //传递多个参数
{
    m_n_rotat_speed += degress;
    return m_n_rotat_speed;
})))) //用了多少个装饰器后面就要多少个),没办法cpp只能这样了，想不出更好的办法，本质是宏嵌套

void CCar::brake(int degress)
DECORATE(logging, ARGS(__FUNCTION__),
//DECORATE(novoid,ARGS(), 使用novoid装饰器无法直接通过编译，因为不支持 void 作为返回值的偏特化
DECORATE(maybe_void,,
//推荐用仿函数的方式实现装饰器，通过构造函数传参封装性更好,如果舍弃函数类型的装饰器的话，就可以少一个宏参数占位了不用打奇怪的两个逗号了，
DECORATE(CheckRotateSpeed(this, __FUNCTION__),,
{
    m_n_rotat_speed -= degress;
})))

//移除decorator相关宏,如果后文遇到重名的宏的话
#include "base/rm_decorator.h"

int main(int , char *[])
{
    CCar car;
    car.oilfeed(45);
    car.brake(1000);
    return 0;
}

各位如果觉得有用，请把 “有用” 打到评论区🤪

尽虹
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python的几个高级语法概念浅析(lambda表达式闭包装饰器)
01-21
1. 匿名函数 匿名函数（anonymous function）是指未与任何标识符绑定的函数，多用在functional programming languages领域，典型应用场合： ...具体语法上，python通过lambda语法支持函数体为表达式的匿名函数，
c/c++宏函数和多参宏函数
aazhoukeaa的博客
08-03 3906
宏函数、多参宏函数
【C/C++进阶】宏函数实用指南
喜欢打篮球的普通人
06-11 1345
// NDEBUG来自：#include // NDEBUG就是release # if defined(NDEBUG) # define CHECK_GL(x) \ do {\(x);\(x);return;} // NDEBUG来自：#include // NDEBUG就是release # if defined(NDEBUG) # define CHECK_GL(x) \ do {\(x);\(x);return;
探索C++中的Python式装饰器
gitblog_00002的博客
06-09 246
探索C++中的Python式装饰器 在编程世界中，Python以其简洁优雅的装饰器功能赢得了广大开发者的心。现在，借助C++14或更高版本，我们有机会体验类似的功能。让我们一起走进C-Python-like-Decorators，一个实现Python装饰器概念的C++开源库。 项目地址:https://gitcode.com/TheMaverickProgrammer/C-Python-like-...
Cpp知识点系列-宏定义
君匡的博客
11-07 703
掌握"宏"概念的关键是“换”。一切以换为前提、做任何事情之前先要换
c++ 常见宏、模板用法【1】
hanhan的博客
03-12 589
记录几个常见的好用的宏和模板编程技巧的示例，它们可以提高代码的可读性、可维护性和灵活性，为开发人员提供了更多的选择和工具来处理复杂的编程问题。
C语言宏定义制作函数模板
锅锅的博客
08-17 2448
一、介绍 当做协议栈或者批量化函数的时候，内容框架是固定的，如果要写1000个10000个函数确实手敲比较麻烦，一种是用工具批量产生这些函数，另一种就是宏定义，这里给出宏定义解决的方法，利用宏定义制作函数模板 二、原理 1、宏定义中##是一种分隔连接方式，它的作用是先分隔，然后进行强制连接 例如:#define hello(x) hello##x hello(123) 等效 hello123 #define A1(name, type) type name_##type##type 或 #define A
Python 利用lambda表达式简化编程 Python源码
11-01
Python 利用lambda表达式简化编程 Python源码Python 利用lambda表达式简化编程 Python源码Python 利用lambda表达式简化编程 Python源码Python 利用lambda表达式简化编程 Python源码Python 利用lambda表达式简化编程 ...
python中的lambda表达式用法详解
01-20
本文实例讲述了python中的lambda表达式用法。分享给大家供大家参考，具体如下： 这里来为大家介绍一下lambda函数。 lambda 函数是一种快速定义单行的最小函数，是从 Lisp 借用来的，可以用在任何需要函数的地方 。...
python中Lambda表达式详解
01-02
如果你在学校读的是计算机科学专业，那么可能学过 Lambda 表达式， 不过可能从来没有用过它。如果你不是计算机科学专业，它们看着可能 有点儿陌生（或者只是“曾经学习过的东西”）。在这一节里，虽然我们 不打算...
C++宏定义
weixin_34378922的博客
07-05 352
1.不带参数的宏定义： 宏定义又称为宏代换、宏替换，简称“宏”。 　　格式： 　　#define 标识符 字符串 　　其中的标识符就是所谓的符号常量，也称为“宏名”。 　　预处理（预编译）工作也叫做宏展开：将宏名替换为字符串。 　　掌握"宏"概念的关键是“换”。一切以换为前提、做任何事情之前先要换，准确理解之前就要“换”。 　　即在对相关命令或语句...
Cpp宏技巧：使用宏自动生成类成员方法等
m0_73298532的博客
04-12 212
其中inline关键字表示这段代码将“内联展开”，其含义是编译器会在调用该函数的地方直接插入函数体的代码，这样可以减少函数调用的开销，尤其是对于那些只有几行代码的短小函数。这个宏定义用于生成CLASS的成员变量，以及相应的设置（方法允许设置成员变量的值，并返回指向当前对象。）来创建一个属性构建器的例子。生成的代码段中，成员变量。这段代码是C++中使用宏定义（拼接起来，形成成员变量的名字。的指针，这使得可以链式调用多个。，并且想要为它创建一个类型为。被设置为私有，并且初始值为。方法则返回成员变量的值。
cpp的一些宏定义总结
变羊法师的博客
12-27 352
cpp常用宏
CPP宏定义解析处理【python】
xiexie1357的专栏
01-13 2448
问题描述 c++宏定义文件中关键字有#define, #undef #ifndef, #ifdef, #else,#endif, 处理注释，//，/*，*/, 解析文件，输出其中的宏定义 分析思路 文本分析基础是字符串处理，宏定义文件的处理需要对遇到的关键字执行特殊的处理。 文件定义的中间数据结构用嵌套列表，宏定义主要是顺序结构和分支结构，顺序结构好理解，一个宏定义作为一个字典，字典作为列...
CPP2022-16-宏、函数重载与函数模板
timberman666的博客
11-17 5709
c++初学习题
cpp的宏和模板的简单介绍
逐梦如风-毕康
10-25 906
cpp的宏和模板的简单介绍宏处理器编译阶段对代码进行预处理,简单的替换，不会进行安全检查宏的名字大写，使用const代替宏，使用内联函数代替宏函数 关于#define 和ifdefine关于\和#和##宏延续运算符（\） 字符串常量化运算符（#） 标记粘贴运算符（##） 模板模板函数语法 template <<#template parameters#>> <#return type#> <#
lambda表达式Python
最新发布
06-24
Lambda表达式是Python中的一种简洁的、匿名的函数定义方式。它们通常用于创建小型的、一次性的函数，不需要使用`def`关键字定义完整的函数名称和文档字符串。Lambda表达式的语法如下： ```python lambda arguments: expression ``` 其中，`arguments`是逗号分隔的一组参数，`expression`是一个表达式，其结果会被直接返回作为函数的结果。 下面是一些使用lambda表达式的例子： 1. **简单的算术运算**: ```python add = lambda x, y: x + y print(add(2, 3)) # 输出: 5 ``` 2. **排序函数中的键**: ```python numbers = [1, 5, 3, 9] sorted_numbers = sorted(numbers, key=lambda x: x) ``` 3. **映射列表**: ```python words = ['apple', 'banana', 'cherry'] capitalized = list(map(lambda word: word.capitalize(), words)) ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值