#define的常规操作

最新推荐文章于 2023-06-18 21:48:38 发布

bingquan3333

最新推荐文章于 2023-06-18 21:48:38 发布

阅读量1.1k

点赞数

分类专栏： C/C++

本文链接：https://blog.csdn.net/bingquan3333/article/details/114745390

版权

C/C++ 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、#define的常规操作

二、#define配合##使用

三、do {...} while (0) 在宏定义中的作用

宏的使用，大家经常会用，但是一般只是简单定义一个符号常量，类似于

#define WHEEL_SCALE_MM 0.53f

#define LOG_I(tag, text_fmt, ...) log_i(tag, text_fmt, ##__VA_ARGS__)

但是除此之外还有宏还有个##粘贴作用，可以配合#define这个常量表达式，可以做成一个宏定义指针函数列表，继而查询执行函数。

一、#define的常规操作

#define预处理器指令和其他预处理器指令一样，以#号作为一行的开始。

ANSI和后来的标准都允许#号前面有空格或制表符，而且还允许在#和指令的其余部分之间有空格。但是旧版本的C要求指令从一行最左边开始，而且#和指令其余部分之间不能有空格。指令可以出现在源文件的任何地方，其定义从指令出现的地方到该文件末尾有效。

我们大量使用#define指令来定义明示常量（manifest constant）（也叫做符号常量）。

预处理器指令从#开始运行，到后面的第1个换行符为止。也就是说，指令的长度仅限于一行。然而，在预处理开始前，编译器会把多行物理行处理为一行逻辑行。

一般我们会用#define 来进行明示常量，或者做一个简单的宏替换函数

#define RX_BUF_SIZE 30
#define MBEDTLS_DES_C        /*数据加密*/
#define ExitIsr   Encoder_Isr   
void Encoder_Isr(void)
{
  g.dir_count += (g.dir == 1)? 1 : -1;

}

每行#define（逻辑行）都由3部分组成。

第1部分是#define指令本身。
第2部分是选定的缩写，也称为宏。有些宏代表值（如本例），这些宏被称为类对象宏。C 语言还有类函数宏，稍后讨论。宏的名称中不允许有空格，而且必须遵循C变量的命名规则：只能使用字符、数字和下划线（_）字符，而且首字符不能是数字。
第3部分（指令行的其余部分）称为替换列表或替换体。

一旦预处理器在程序中找到宏的实例后，就会用替换体代替该宏。从宏变成最终替换文本的过程称为宏展开。注意，可以在#define行使用标准C注释。如前所述，每条注释都会被一个空格代替。

此外我们还会比较多的使用可变参数宏(variadic macros)--VA_ARGS

通过把宏定义中参数列表最后的一个参数写成省略号，来实现这一功能。这样，预定义宏_ _VA_ARGS_ _可用在替换部分中，表明省略号代表什么。

#define PR(...) printf(_ _VA_ARGS_ _)

假设稍后调用该宏：

PR("Howdy");
PR("weight = %d, shipping = $%.2f\n", wt, sp);

对于第1次调用， _ _VA_ARGS_ _展开为1个参数："Howdy"。
对于第2次调用， _ _VA_ARGS_ _展开为3个参数："weight = %d, shipping = $%.2f\n"、 wt、 sp。

因此，展开后的代码是：

printf("Howdy");
printf("weight = %d, shipping = $%.2f\n", wt, sp);

二、#define配合##使用

很多人应该都知道"##"的用法，它被称为预处理的粘合剂，与#运算符类似，##运算符可用于类函数宏的替换部分。而且，##还可以用于对象宏的替换部分。##运算符可以把两个记号组合成一个记号。

#define def_u32_array(__name, __size)     uint32_t array_##__name[__size];

实际中，我们可以这样使用：

def_u32_array(sample_buffer, 64)

宏展开的效果是：

uint32_t array_sample_buffer[64];

同样类比于初始化一个数组，我们也可以粘贴形成一个函数

下面就是在Linux内核里面的源代码：

其中这个__pcpu_size_call_return宏，通过##粘贴选择要使用的raw_cpu_read_x 函数。

#define __pcpu_size_call_return(stem, variable)        \
({                  \
  typeof(variable) pscr_ret__;          \
  __verify_pcpu_ptr(&(variable));          \
  switch(sizeof(variable)) {          \
  case 1: pscr_ret__ = stem##1(variable); break;      \
  case 2: pscr_ret__ = stem##2(variable); break;      \
  case 4: pscr_ret__ = stem##4(variable); break;      \
  case 8: pscr_ret__ = stem##8(variable); break;      \
  default:              \
    __bad_size_call_parameter(); break;      \
  }                \
  pscr_ret__;              \
})

#define raw_cpu_read_1(pcp)    raw_cpu_generic_read(pcp)
#define raw_cpu_generic_read(pcp)          \
({                  \
  *raw_cpu_ptr(&(pcp));            \
})

这部分是更高层次的宏定义，将##粘贴的函数再次定义为一个宏函数

#define raw_cpu_read(pcp)       __pcpu_size_call_return(raw_cpu_read_, pcp)

#define __this_cpu_read(pcp)                        \
({                                  \
    __this_cpu_preempt_check("read");               \
    raw_cpu_read(pcp);                      \
})

最后面进行执行 __this_cpu_read(current_kprobe);

int __kprobes arc_kprobe_handler(unsigned long addr, struct pt_regs *regs)
{
  struct kprobe *p
  p = __this_cpu_read(current_kprobe);
  p = get_kprobe((unsigned long *)addr);
  
  ... 省略多行代码
  
  if (p->break_handler && p->break_handler(p, regs)) {
    setup_singlestep(p, regs);
    kcb->kprobe_status = KPROBE_HIT_SS;
    return 1;
}

在C++中我们也可以将做成一个指针列表，对应好每个函数的名称后，再次调用该定义的宏参数，就实现了指针调用。

#define AddFunc(Func) \
FuncPtrTemplate Func##Map(int mode_name, int state_name) \
{ \
    static auto modeMap = Func##Register(); \
    auto pair = std::make_pair(mode_name, state_name); \
    auto mapEntry = modeMap->find(pair); \
    if (mapEntry == modeMap->end()) \
        return nullptr; \
    return mapEntry->second; \
} \
bool Mode::Func(State *state) { \
    auto state_id = getStateId(); \
    auto p_function = Func##Map(getId(), state_id); \
    if (p_function) \
        return p_function(this, state); \
    return false; \
}
AddFunc(IsExit);

int main(){
  IsExit(p.get());
}

这也是Linux内核中的代码，用来print不同状态的打印信息，如果大家想要快速掌握这些使用方法，建议大家撸一撸Linux内核源码呢。

三、do {...} while (0) 在宏定义中的作用

在很多的C程序中，你可能会看到许多看起来不是那么直接的较特殊的宏定义。下面就是一个例子：

#define __set_task_state(tsk, state_value)      \
    do { (tsk)->state = (state_value); } while (0)

在Linux内核和其它一些著名的C库中有许多使用do{...}while(0)的宏定义。这种宏的用途是什么？有什么好处？

Google的Robert Love（先前从事Linux内核开发）给我们解答如下：

do{...}while(0)在C中是唯一的构造程序，让你定义的宏总是以相同的方式工作，这样不管怎么使用宏（尤其在没有用大括号包围调用宏的语句），宏后面的分号也是相同的效果。

这句话听起来可能有些拗口，其实用一句话概括就是：使用do{...}while(0)构造后的宏定义不会受到大括号、分号等的影响，总是会按你期望的方式调用运行。

例如：

#define foo(x) bar(x); baz(x)

然后你可能这样调用：

foo(wolf);

这将被宏扩展为：

bar(wolf); baz(wolf);

这的确是我们期望的正确输出。下面看看如果我们这样调用：

if (!feral)
    foo(wolf);

那么扩展后可能就不是你所期望的结果。上面语句将扩展为:

if (!feral)
    bar(wolf);
baz(wolf);

显而易见，这是错误的，也是大家经常易犯的错误之一。

几乎在所有的情况下，期望写多语句宏来达到正确的结果是不可能的。你不能让宏像函数一样行为——在没有do/while(0)的情况下。

如果我们使用do{...}while(0)来重新定义宏，即：

#define foo(x) do { bar(x); baz(x); } while (0)

现在，该语句功能上等价于前者，do能确保大括号里的逻辑能被执行，而while(0)能确保该逻辑只被执行一次，即与没有循环时一样。

对于上面的if语句，将会被扩展为：

if (!feral)
    do { bar(wolf); baz(wolf); } while (0);

从语义上讲，它与下面的语句是等价的：

if (!feral) {
    bar(wolf);
    baz(wolf);
}

这里你可能感到迷惑不解了，为什么不用大括号直接把宏包围起来呢？为什么非得使用do/while(0)逻辑呢？

例如，我们用大括号来定义宏如下：

#define foo(x)  { bar(x); baz(x); }

这对于上面举的if语句的确能被正确扩展，但是如果我们有下面的语句调用呢：

if (!feral)
    foo(wolf);
else
    bin(wolf);

宏扩展后将变成：

if (!feral) {
    bar(wolf);
    baz(wolf);
};
else
    bin(wolf);

大家可以看出，这就有语法错误了。

总结：Linux和其它代码库里的宏都用do/while(0)来包围执行逻辑，因为它能确保宏的行为总是相同的，而不管在调用代码中使用了多少分号和大括号。

例子：#define配合##，以及do {...} while (0) 在宏定义中的使用

我们定义宏 PAGE_REG(name)

/*页面注册器*/
#define PAGE_REG(name)\
do{\
    extern void PageRegister_##name(uint8_t pageID);\
    PageRegister_##name(PAGE_##name);\
}while(0)

这样调用

    PAGE_REG(DialPlate);    //表盘

这样被宏展开为

do{
    extern void PageRegister_DialPlate(uint8_t pageID);
    PageRegister_DialPlate(PAGE_DialPlate);
}while(0)

被调用的函数

typedef enum
{
    /*保留*/
    PAGE_NONE,
    /*用户页面*/
    PAGE_DialPlate,
    PAGE_MainMenu,
    PAGE_TimeCfg,
    PAGE_Backlight,
    PAGE_StopWatch,
    PAGE_Altitude,
    PAGE_About,
    PAGE_Game,
    /*保留*/
    PAGE_MAX
} Page_Type;


/**
  * @brief  页面注册
  * @param  pageID:为此页面分配的ID号
  * @retval 无
  */
void PageRegister_DialPlate(uint8_t pageID)
{
    /*获取分配给此页面的窗口*/
    appWindow = AppWindow_GetCont(pageID);
    
    /*注册至页面调度器*/
    page.PageRegister(pageID, Setup, NULL, Exit, Event);
}