搜索
bottom↓
回复: 51

【为宏正名】99%人都不知道的"##"里用法

  [复制链接]

出0入296汤圆

发表于 2020-7-22 05:38:48 | 显示全部楼层 |阅读模式
本帖最后由 Gorgon_Meducer 于 2020-7-22 20:35 编辑


【说在前面的话】

有人说C语言中最臭名昭著的两兄弟就是指针和宏了。对于前者,很多有经验的老鸟会告诉你:用好了指针你就掌握了
C语言的内功心法——如同原力一样,无论是追随光明还是堕入黑暗都离不开它。宏就没这么幸运了,不光年年受到邪
恶的混乱C语言大赛的肆意霸凌(https://www.ioccc.org/),更是让“让代码爹妈都
不认识”的身份标签贴到了骨头上——怎一个惨字了得。



这个系列将本着实用的原则介绍一些宏在模块封装中“点石成金”的用法,让大家正确认识
到宏真实的作用和使用规则——真真正正还“宏”一个公道。

【"##"的“表”用法】

想必很多人都知道"##"的用法——它本质上是一个“胶水运算”,用于把参数宏中的“形参”与其它没
有天然分割的内容
粘连在一起,例如:
  1. #define def_u32_array(__name, __size)     \
  2.      uint32_t array_##__name[__size];
复制代码
实际中,我们可以这样使用:
  1. def_u32_array(sample_buffer, 64)
复制代码
宏展开的效果是:
  1. uint32_t array_sample_buffer[64];
复制代码
可以看到,"array__"与形参“__name”是没有天然分割的,因此要想将
"array_"与"__name"所代表的内容(而不是__name本身)粘连在一起,就需要“##”运算的帮助。另一方面,"__name"
与"["是具有天然分隔的——编译器不会认为"__name"与"["是连接在一起的,因此这里并不需要画蛇添足的使用"##"运
算——如果你这么做了,预编译器会毫不犹豫的告诉你语法错误。——这是"##"运算的普通用法,在过去转载的文章
C语言#和##连接符在项目中的应用(漂亮)》中也有详细介绍,这里就不再赘述。

【"##"的官方“里”用法】

“##”还有一个很少为人所知的“里”用法,在介绍它之前,不得不首先说说由ANSI-C99标准引入的另外一个参数宏扩
展——可变参数宏。举个例子:


    1. #define safe_atom_code(...)                          \
    2.         {                                            \
    3.             uint32_t int_flag = __disable_irq();     \
    4.             __VA_ARGS__                              \
    5.             __set_PRIMASK(int_flag);                 \
    6.         }
    复制代码

    这里定义了一个宏"safe_atom_code()",在括号内,无论你填写任何内容,都会被无条件的放置到“__VA_ARGS__”所在
    的位置,你可以认为括号里的“...”实际上就是对应"__VA_ARGS__"。比如,我们可以写下这样的代码:
    1. /**  \fn          void wr_dat (uint16_t dat)
    2.   \brief       Write data to the LCD controller
    3.   \param[in]   dat  Data to write
    4. */
    5. static __inline void wr_dat (uint_fast16_t dat) {
    6.     safe_atom_code(
    7.         LCD_CS(0);
    8.         GLCD_PORT->DAT = (dat >>   8);
    9.    /* Write D8..D15 */
    10.         GLCD_PORT->DAT = (dat & 0xFF);
    11.    /* Write D0..D7 */
    12.         LCD_CS(1);
    13.     )
    14. }
    复制代码
    这个代码确保在向寄存器GCLD_PORT->DAT写入数据时不会被其它中断打断。
    聪明的你也许很快就会提出这样的问题,上述宏跟下面的写法有什么区别呢?
    1. #define safe_atom_code(__CODE)                       \
    2.         {                                            \
    3.             uint32_t int_flag = __disable_irq();     \
    4.             __CODE                                   \
    5.             __set_PRIMASK(int_flag);                 \
    6.         }
    复制代码

    你不仅提出了问题,甚至还实际测试了下,似乎完全等效,“根本没差别嘛!”——你惊呼道。然而,事实上并没有那么简单:
参数宏是通过“,”来作为分隔符来计算用户实际产传入了几个参数的,或者换句话说,在使用参
数宏的时候,预编译器是看不懂C语法的——在它眼中,除了它所认识的少数符号外,其它东西都是无意义的字符串——由于
在处理括号内部的内容时,它只认识","和"...",因此当括号中的内容每增加一个",",与编译器就认为多了一个参数。当你使
用参数宏的时候,传入参数的个数(已“,”分开)必须与定义参数宏时候形参的数量完全一致
;当不一致的时候,
预编译器可能不会报错,而是直接无视了你的参数宏——把它传递到编译的下一阶段,因而往往会被认作是一个函数——事实
上这个函数是不存在的,因此在链接阶段会报告某某函数未定义的错误。这时候你就会纳闷了,为啥我明明定义的是一个宏,
编译器却把它当作函数呢?

可变参数宏的引入就解决了这个问题:
  • "..."只能放在参数宏形参列表的最后;
  • 当用户的参数个数超过了规定的参数个数时,所有多出来的内容会一股脑的由“__VA_ARGS__”所背负;
  • 当用户的参数个数正好等于形参的个数时,"__VA_ARGS__"就等效于一个空字符串

回头再来看前面的问题,
  1. #define safe_atom_code(...)
复制代码

  1. #define safe_atom_code(__CODE)
复制代码
的差别在于,前者括号里可以放包括","在内的几乎任意内容;而后者则完全不
能容忍逗号的存在——比如你调用了一个函数,函数的参数要用到都好隔开吧?再比如,你用到了逗号表达式……——想想都很
酸爽。
其实,可变参数列表最初诞生的原因之一是为了解决与C函数的可变参数(va_args)配合使用的问题,例如:
  1. #define log_info(__STRING, ...)    printf(__STRING, __VA_ARGS__)
复制代码
因此,使用的时候,我们可以这样写:
  1. log_info("------------------------------------\r\n");
  2. log_info(" Cycle Count : %d", total_cycle_cnt);
复制代码
宏展开后实际上对应于:
  1. printf("------------------------------------\r\n",);
  2. printf(" Cycle Count : %d", total_cycle_cnt);
复制代码
看似没有问题,注意到一个细节没有?在第一个printf()的最后多了一个","。
虽然有些编译器,例如GCC并不会计较(也许就是一个warning),但对于广大洁癖严重的处女座程序员来说,这怎么能忍,于是
在ANSI-C99标准引入可变参数宏的时候,又贴心了加了一个不那么起眼的语法:当下面的组合出现时 ",##__VA_ARGS__",
如果__VA_ARGS__是一个空字符串,则前面的","会一并被删除掉
。因此,上面的宏可以改写为:
  1. #define log_info(__STRING, ...)    printf(__STRING,##__VA_ARGS__)
复制代码
此时,前面的代码会被展开为:
  1. printf("------------------------------------\r\n");
  2. printf(" Cycle Count : %d", total_cycle_cnt);
复制代码
处女座表示,这次可以安心睡觉了。

如果说这就是99%的C程序员都不知道的"##"隐藏用法,未免太对不起观众了,实际上本文的正片才刚刚开始。

【正文:"##"的骚操作】

逗号表达式,一直关注公众号的朋友们想必都很熟悉——之前转载的文章《【C进阶】听说用 “ 逗号表达式 ” 仅仅为了秀技?》已经说的非常详细了,
这里就不再赘述。简单说,就是逗号表达式中,逗号的最右边将作为表达式真正的返回值。
结合前面关于",##__VA_ARGS__"用法的介绍,你们有没有意识到,其实这里的逗号不光可以是参数列表的分隔符,还可以是逗号
表达式的运算符。结合__VA_ARGS__的特性,我们可以写出类似这样的宏:
  1. #define EXAMPLE(...)     ( 默认值 ,##__VA_ARGS__)
复制代码
它有两种使用情况情况:
当我们使用参数宏的时候在括号里不填写任何内容,最终会展开为仅有默认值的情况:

  1. EXAMPLE();
复制代码
被展开为:
  1. ( 默认值 )
复制代码
当我们提供了任意的有效值时,则会被展开成逗号表达式:
  1. EXAMPLE(我们提供的值);
复制代码
被展开为:
  1. ( 默认值, 我们提供的值 )
复制代码
根据逗号表达式的特性,此时,默认值会被丢弃掉(有些编译器会报告
表达式无效的warning,这是正常的,因为编译器注意到“默认值”所代表的表达式实际上被丢弃了,它觉得我们写了一个无用的表
达式
)。

这个技巧其实对API的封装特别有效:它允许我们简化函数API的使用,比如在用户忽略的情况下,自动给函数填充
某些默认值,而在用户主动提供参数的情况下,替代那些默认值。这里我举两个现实中的例子:


  • 为函数提供默认的参数

假设我们有一个初始化函数,初始化函数允许用户通过结构体来配置一些参数:

  1. typedef struct xxxx_cfg_t {
  2.     ...
  3. } xxxx_cfg_t;
  4. int xxxx_init(xxxx_cfg_t *cfg_ptr);
复制代码

为了简化用户的配置过程,初始化函数会检查指针cfg_ptr是否为NULL,如果为NULL则自动使用默认配置,反之将使用用户定义的
配置。此时,我们可以通过宏来提供默认值NULL:
  1. #define XXXX_INIT(...)    xxxx_init((NULL,##__VA_ARGS__))
复制代码

  • 为消息处理提供默认的掩码配置

有些消息处理函数可以批量的处理某一类消息,而具体选中了哪些消息类别,则通常由二进制掩码来表示,
例如:

  1. typedef struct msg_t msg_t;
  2. struct msg_t {
  3.     uint16_t msg;
  4.     uint16_t msk;
  5.     int (*handler)(msg_t *msg_ptr);
  6. };
复制代码
此时我们完全可以借助宏来构建一套语法糖:
  1. #define def_msg_map(__name, ...)                            \
  2.     const msg_t __name[] = {__VA_ARGS__};   
  3. #define add_msg(__msg, __handler, ...)                      \
  4.     {                                                       \
  5.         .msg = (__msg),                                     \
  6.         .handler = &(__handler),                            \
  7.         .msk = (0xFFFF, ##__VA_ARGS__),                     \
  8.     }
复制代码
通过宏 add_msg 我们注意到,当用户刻意省略设置msk时,我们就给出默认值 0xFFFF——这很可能表示,在进
行消息处理的时候,消息必须严格匹配才能交给对应的处理函数;当用户指定 msk 时,则可能表示某一类消息都交给同一
个消息处理函数来处理。例如:

  1. /*! \note 高字节表示操作的类别:
  2.           比如0x00表示控制类,0x01表示WRITE,0x02表示READ
  3. */
  4. enum {
  5.     SIGN_UP      = 0x0001,
  6.     WRITE_MEM    = 0x0100,
  7.     WRITE_SRAM   = 0x0101,
  8.     WRITE_FLASH  = 0x0102,
  9.     WRITE_EEPROM = 0x0103,
  10.     READ_MEM     = 0x0200,
  11.     READ_SRAM    = 0x0201,
  12.     READ_FLASH   = 0x0202,
  13.     READ_EEPROM  = 0x0203,
  14. };

  15. extern int iap_sign_up_handler(msg_t *msg_ptr);
  16. extern int iap_write_mem(msg_t *msg_ptr);
  17. extern int iap_read_mem(msg_t *msg_ptr);


  18. def_msg_map( iap_message_map,

  19.     /* 严格的将 SIGN_UP 映射到 对应的处理函数中 */
  20.     add_msg( SIGN_UP,   iap_sign_up_handler ),

  21.     /* 批量处理所有的WRITE操作,使用掩码进行过滤*/
  22.     add_msg( WRITE_MEM, iap_write_mem,       0xFF00 ),

  23.      /* 批量处理所有的READ操作,使用掩码进行过滤 */
  24.     add_msg( READ_MEM,  iap_read_mem,        0xFF00 ),

  25. )
复制代码

【结语】

宏不是阻碍代码开发和可读性的魔鬼,对自己不熟悉知识的傲慢才是。

干货创作不易,如果你觉得我的文章对你有所帮助,还请打赏、点赞、收藏和三连。   
            

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x

阿莫论坛20周年了!感谢大家的支持与爱护!!

一只鸟敢站在脆弱的枝条上歇脚,它依仗的不是枝条不会断,而是自己有翅膀,会飞。

出0入4汤圆

发表于 2020-7-22 05:50:53 来自手机 | 显示全部楼层
学习了,宏的秒用!

出0入0汤圆

发表于 2020-7-22 06:24:34 来自手机 | 显示全部楼层
学习了,感谢楼主分享

出0入0汤圆

发表于 2020-7-22 06:29:26 来自手机 | 显示全部楼层
学习一下。

出0入42汤圆

发表于 2020-7-22 06:37:13 来自手机 | 显示全部楼层
好久不见了啊,大侠!

出0入0汤圆

发表于 2020-7-22 06:44:25 | 显示全部楼层
楼主有几个地方错了…

出0入93汤圆

发表于 2020-7-22 07:06:46 | 显示全部楼层
受教了,还真没有仔细分析过__VA_ARGS__和##__VA_ARGS__的区别,因为我用的GCC C++容忍度太高了,就算末尾有个,它也不警告还可以正常跑

但是逗号表达式那个很强,然而我是不会用的,这玩意跟编译器相关,被坑过有教训了,不遵守规则的编译器在这里埋坑故放弃。比如STM8的Cosmic编译器,Debug模式逗号表达式工作得很好,Release模式如果前面的语句有副作用就有可能优化掉部分语句干瞪眼了,当然您这个它不可能短路掉,但还是坚守原则好点,不用逗号表达式。
MISRA:规则 12.10 (强制): 不要使用逗号运算符。
还是听编码规范的吧。

出0入0汤圆

发表于 2020-7-22 07:52:54 来自手机 | 显示全部楼层
赞!硬硬的干货^_^

出10入0汤圆

发表于 2020-7-22 07:55:04 | 显示全部楼层
可能是编辑器粘贴的问题,楼主老师第一个代码

  1. #define def_u32_array(__name, __size)     \
  2.          uint32_t array_##__name

  3. def_u32_array(sample_buffer, 64)
复制代码


改成

  1. #define def_u32_array(__name, __size)     \
  2.          uint32_t array_##__name[__size]

  3. def_u32_array(sample_buffer, 64);
复制代码


就能正常工作了。

出0入0汤圆

发表于 2020-7-22 08:01:17 | 显示全部楼层
硬硬的干货^_^

出10入79汤圆

发表于 2020-7-22 08:21:20 | 显示全部楼层
硬核。收藏了。

出16370入6742汤圆

发表于 2020-7-22 08:48:32 来自手机 | 显示全部楼层
打赏50汤圆。

出330入0汤圆

发表于 2020-7-22 09:01:44 来自手机 | 显示全部楼层
打赏20汤圆。总是长篇大论,只好以后再来看

出0入30汤圆

发表于 2020-7-22 09:10:09 | 显示全部楼层
MARK。收藏学习。

出0入0汤圆

发表于 2020-7-22 09:36:15 | 显示全部楼层
好久不见啊

出190入0汤圆

发表于 2020-7-22 10:11:26 | 显示全部楼层
应该是这样吧:
#define def_u32_array(__name, __size)     \
     uint32_t array_##__name[__size]

出0入0汤圆

发表于 2020-7-22 10:51:26 来自手机 | 显示全部楼层
收藏再看,这个是我不懂的地方

出500入203汤圆

发表于 2020-7-22 10:57:27 | 显示全部楼层
写了好多年的代码, 最近才开始真的接触不定参数, 逗号表达, 正则运算, 库函数. 见到了这些才发现, 自己的C语音居然都算不上真正的入门.

出500入203汤圆

发表于 2020-7-22 11:04:59 | 显示全部楼层
向大佬咨询下, IAR 中不同结构体的成员名称, 为什么一定要不同, 有办法在不同结构体中定义相同的成员名吗

出0入0汤圆

发表于 2020-7-22 11:59:53 | 显示全部楼层
本帖最后由 Gorgon_Meducer 于 2020-8-8 00:54 编辑

  1. enum {
  2.     LOG_LEVEL_OFF = 0,
  3.     LOG_LEVEL_FATAL = 1,
  4.     LOG_LEVEL_ERROR = 2,
  5.     LOG_LEVEL_WARN = 3,
  6.     LOG_LEVEL_INFO = 4,
  7.     LOG_LEVEL_DEBUG = 5,
  8.     LOG_LEVEL_ALL = 6,
  9. };
  10. #define  LOG_LEVEL_GLOBAL   LOG_LEVEL_ALL
  11. #define LOG_LEVEL_CUR   LOG_LEVEL_WARN
  12. #define LOG_FATAL(IF, CONTENT, ...) \
  13.     if((IF) && (LOG_LEVEL_GLOBAL >= LOG_LEVEL_FATAL) && (LOG_LEVEL_CUR >= LOG_LEVEL_FATAL)) { \
  14.     printf("[F] "); \
  15.     printf(__FUNCTION__); \
  16.     printf(": "); \
  17.     CONTENT \
  18.     puts("."); \
  19.     __VA_ARGS__ \
  20. }

  21. int func(const char *p)
  22. {
  23.     LOG_FATAL(
  24.         p == NULL,
  25.         printf("p is null.");
  26.         printf(" exit");,
  27.         return 1;
  28.     );
  29.     ... ...
  30. }
复制代码

平时喜欢这么用

出0入8汤圆

发表于 2020-7-22 12:04:43 | 显示全部楼层
考考大家,是否真的读懂了楼主的旷世大作:
#define KK(...) 1,##__VA_ARGS__

1.int a = 1,2;
2.int b = KK();
3.int c = KK(3);
4.int d = (KK(4));

那几个可以编译过

出0入0汤圆

发表于 2020-7-22 12:15:20 | 显示全部楼层
先MARK下,再慢慢看

出50入255汤圆

发表于 2020-7-22 12:23:29 | 显示全部楼层
向大师 致敬!
## 只用过这个功能
-----------------------------------------
它本质上是一个“胶水运算”,用于把参数宏中的“形参”与其它没
有天然分割的内容粘连在一起
-----------------------------------------
您的状态机,一直想用,一直用不起来。

出0入0汤圆

发表于 2020-7-22 12:23:42 | 显示全部楼层
不错,虽然不时有用过,但是没有总结出来..............

出0入0汤圆

发表于 2020-7-22 13:10:47 | 显示全部楼层
学习了!!!

出0入0汤圆

发表于 2020-7-22 14:49:37 | 显示全部楼层
大师又开讲了,学习中……

出0入0汤圆

发表于 2020-7-22 18:07:39 | 显示全部楼层
yoz 发表于 2020-7-22 07:55
可能是编辑器粘贴的问题,楼主老师第一个代码

还有个地方要改:

typedef struct msg_t msg_t;
struct {
    uint16_t msg;
    uint16_t msk;
    int (*handler)(msg_t *msg_ptr);
} msg_t;

改成typedef struct msg_t msg_t;
struct msg_t{
    uint16_t msg;
    uint16_t msk;
    int (*handler)(msg_t *msg_ptr);
};

出100入18汤圆

发表于 2020-7-22 18:18:34 | 显示全部楼层
感谢讲解!学习中。

出0入0汤圆

发表于 2020-7-22 18:51:34 | 显示全部楼层
硬核,学习了。

出0入296汤圆

 楼主| 发表于 2020-7-22 20:17:33 | 显示全部楼层
takashiki 发表于 2020-7-22 07:06
受教了,还真没有仔细分析过__VA_ARGS__和##__VA_ARGS__的区别,因为我用的GCC C++容忍度太高了,就算末尾 ...

不是所有应用都要遵守 MISRA 规范…… 否则大家都用C90/89好了。
逗号表达式以及__VA_ARGS__只是个工具,根据情况灵活使用就好。我其实不相信大部分人的工作都要遵守MISRA规范,那就真是miserable了。

出0入296汤圆

 楼主| 发表于 2020-7-22 20:23:58 | 显示全部楼层
ziziy 发表于 2020-7-22 18:07
还有个地方要改:

typedef struct msg_t msg_t;

没错,是笔误。

出0入296汤圆

 楼主| 发表于 2020-7-22 20:25:48 | 显示全部楼层
xy-mcu 发表于 2020-7-22 12:23
向大师 致敬!
## 只用过这个功能
-----------------------------------------

你是说那个模板么?

出0入296汤圆

 楼主| 发表于 2020-7-22 20:27:05 | 显示全部楼层
momo_li 发表于 2020-7-22 11:04
向大佬咨询下, IAR 中不同结构体的成员名称, 为什么一定要不同, 有办法在不同结构体中定义相同的成员名吗 ...

我没有遇到过这个问题……给个例子?

出0入296汤圆

 楼主| 发表于 2020-7-22 20:36:59 | 显示全部楼层
uindex 发表于 2020-7-22 12:04
考考大家,是否真的读懂了楼主的旷世大作:
#define KK(...) 1,##__VA_ARGS__

谢谢你的练习题,这里是参考答案的提示:
定义宏的时候要打括号……

出0入0汤圆

发表于 2020-7-22 23:44:09 | 显示全部楼层
学习一下。

出0入4汤圆

发表于 2020-7-23 10:38:08 | 显示全部楼层

学习一下。

出0入0汤圆

发表于 2020-7-23 11:40:41 | 显示全部楼层
宏的这种用法好是好, 就是用来连一下名称就好, 用多了可会走火入魔的, 比指针更危险!!!!

出0入0汤圆

发表于 2020-7-23 15:45:08 | 显示全部楼层
学习一下。

出50入0汤圆

发表于 2020-7-23 16:16:12 | 显示全部楼层
学习一下。

出0入0汤圆

发表于 2020-7-23 16:44:10 | 显示全部楼层
刚刚阅读##代码,好吧,宏不是阻碍代码开发和可读性的魔鬼。。。。

出0入0汤圆

发表于 2020-7-23 17:02:15 | 显示全部楼层
已阅读,待领会

出0入0汤圆

发表于 2020-7-23 19:24:16 | 显示全部楼层
本帖最后由 jjj 于 2020-7-23 19:34 编辑

为什么要写这么晦涩难懂的程序,
void
memp_init(void)
{
  u16_t i;
  /* for every pool: */
  for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) {
    memp_init_pool(memp_pools);
}
LWIP里的这个内存分配,让我分析了半年也没弄明白

突然明白,把代码写成这样的目的就是不想让我看明白,  普通用户也无需明白,   会用LWIP不代码里面的每个细节都明白。

如果把LWIP的网卡驱动也这样搞的话,估计就没有人用了,如果把LWIP  的  UDP TCP编程也这样搞的话,   估计我们就不会知道LWIP的存在了

出0入0汤圆

发表于 2020-7-23 19:28:41 | 显示全部楼层
深度好文, 标记。

出0入0汤圆

发表于 2020-7-23 21:37:42 | 显示全部楼层
good,,不错,,,

出0入0汤圆

发表于 2020-7-24 00:27:06 | 显示全部楼层
这个用着用着容易上瘾,有问题单步调试就有点恶心了

出0入296汤圆

 楼主| 发表于 2020-8-8 00:28:04 | 显示全部楼层
xflm 发表于 2020-7-22 11:59
enum {
    LOG_LEVEL_OFF = 0,
    LOG_LEVEL_FATAL = 1,

好东西,谢谢分享。

出0入296汤圆

 楼主| 发表于 2020-8-8 00:29:16 | 显示全部楼层
onepower 发表于 2020-7-23 11:40
宏的这种用法好是好, 就是用来连一下名称就好, 用多了可会走火入魔的, 比指针更危险!!!! ...

知道规则以后,就是正确的对规则的使用而已,“走火入魔”我觉得是一种挺主观的情绪化描述。

出0入296汤圆

 楼主| 发表于 2020-8-8 00:48:57 | 显示全部楼层
amdzid 发表于 2020-7-24 00:27
这个用着用着容易上瘾,有问题单步调试就有点恶心了

目前介绍的东西除了 safe_atom_code() 括号填写代码这个部分以外,都不影响单步。
但其实对于safe_atom_code() 不能单步的问题,我后面有另外一个解决方法,对应的,推荐的写法是


  1. safe_atom_code() {
  2.     ...
  3. }
复制代码


而不是

  1. safe_atom_code(
  2.     ...
  3. )
复制代码


这也算一种技巧吧,其实本质上就是用了 for(;;) 的特性做了一个宏封装而已,比如



  1. #define __CONNECT2(a,b)         a##b
  2. #define CONNECT2(a,b)           __CONNECT2(a,b)

  3. #define safe_atom_code()                                                                        \
  4.     for(uint32_t CONNECT2(int_status,__LINE__) =__disable_irq(),                \
  5.             CONNECT2(stop_flag,__LINE__) = 1;                                   \
  6.         CONNECT2(stop_flag,__LINE__)-- >0;                                      \
  7.         __set_PRIMASK(CONNECT2(int_status,__LINE__)))

复制代码


使用的时候这样:

  1.     safe_atom_code() {
  2.         /* put your code here */
  3.         ...
  4.     }
复制代码


在花括号里的代码就可以下断点了。一种可能的展开结果是这样的:


  1. # 68 "main.c"
  2. for(uint32_t int_status68 =__disable_irq(), stop_flag68 = 1; stop_flag68-- >0; __set_PRIMASK(int_status68)) {
  3.     /* put your code here */
  4. }
复制代码

出0入296汤圆

 楼主| 发表于 2020-8-8 00:51:15 | 显示全部楼层
本帖最后由 Gorgon_Meducer 于 2020-8-8 00:53 编辑
jjj 发表于 2020-7-23 19:24
为什么要写这么晦涩难懂的程序,
void
memp_init(void)


很正确,代码是给你用的,并不是拿来给你做教育品的——你非要拿一个使用目的的工具来研究怎么制造这个
工具的,然后抨击别人封装的太严实让你不好拆,你让工具的制造商怎么想?哭笑不得吧?

另外,你举例的这个代码,讲真……可读性非常好……我并不觉得他晦涩难懂……

出0入8汤圆

发表于 2020-8-8 08:35:09 来自手机 | 显示全部楼层
jjj 发表于 2020-7-23 19:24
为什么要写这么晦涩难懂的程序,
void
memp_init(void)

如果这个都看不明白,这边建议您换个工作

出0入0汤圆

发表于 2020-8-8 09:33:54 | 显示全部楼层
canspider 发表于 2020-8-8 08:35
如果这个都看不明白,这边建议您换个工作


换不了了,俺是公司的嵌入式专家,  俺换工作公司会倒闭的

出0入296汤圆

 楼主| 发表于 2020-8-8 22:24:54 | 显示全部楼层
jjj 发表于 2020-8-8 09:33
换不了了,俺是公司的嵌入式专家,  俺换工作公司会倒闭的

注意保护身体,保护头发。保重,兄弟。
回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片,浪费大家下载带宽和论坛服务器空间,请压缩后(图片小于1兆)才上传。压缩方法可以在微信里面发给自己(不要勾选“原图),然后下载,就能得到压缩后的图片】。另外,手机版只能上传图片,要上传附件需要切换到电脑版(不需要使用电脑,手机上切换到电脑版就行,页面底部)。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有:东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案:44190002001997 ) )

GMT+8, 2024-6-17 21:40

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表