C语言define高级用法大全

最新推荐文章于 2024-05-12 16:29:08 发布

小熊coder

最新推荐文章于 2024-05-12 16:29:08 发布

阅读量1.5w

点赞数 29

分类专栏： C语言文章标签： c语言

本文链接：https://blog.csdn.net/qq_41854911/article/details/121196531

版权

C语言专栏收录该内容

128 篇文章 150 订阅

订阅专栏

今天在看代码时，突然发现很多define的用法看不懂，故在此总结一下，顺便吐槽一下，C语言的宏复杂起来真的很难看懂。

不信的去看下这个的源码：【C语言开源库】lw_oopc：轻量级的C语言面向对象编程框架

一、宏的定义与撤销

640?wx_fmt=png

需要注意的是：

（1）宏定义应注意添加括号，这样语义会比较清晰。

（2）使用#undef可以撤销宏定义。

（3）引号中的宏定义不会被替换。

（4）宏定义的宏名必须是合法的标识符。

（5）宏定义中单、双引号必须成对出现。

二、带有参数的宏定义

640?wx_fmt=png

需要注意的是：

（1）宏调用时参数的个数要与定义时相同。

三、跨行的宏定义，使用反斜杠分隔

640?wx_fmt=png

这种跨行的代码就是函数宏的感觉了。

#include "stdio.h"

#define test(x,y) do \
	 {               \
	 	int a = x;   \
	 	int b = y;   \
	 	printf("%d",a); \
	 }while(0);       \
	 int a = x + y;
	 
int main() {
	test(1,2);
	printf("%d",a);
}

四、三个特殊符号：****#，##，#@

640?wx_fmt=png

五、常见的宏定义

1、防止头文件被重复包含

640?wx_fmt=png

2、得到指定地址上的一个字节值或字值

640?wx_fmt=png

3、得到一个field在结构体(struct)中的偏移量

#define OFFSETOF( type, field ) ( (size_t) &(( type *) 0)-> field )

4、*得到一个结构体中field所占用的字节数

#define FSIZ( type, field ) sizeof( ((type *) 0)->field )

5、得到一个变量的地址（word宽度）

#define B_PTR(var) ( (byte *) (void *) &(var) ) 
#define W_PTR(var) ( (word *) (void *) &(var) )

6、将一个字母转换为大写

#define UPCASE(c) ( ((c) >= 'a' && (c) <= 'z') ? ((c) - 0x20) : (c) )

7、判断字符是不是10进制的数字

#define DECCHK(c) ((c) >= '0' && (c) <= '9')

8、判断字符是不是16进制的数字

#define HEXCHK(c) (((c) >= '0' && (c) <= '9') ||((c) >= 'A' && (c) <= 'F') ||((c) >= 'a' && (c) <= 'f'))

9、防止溢出的一个方法

#define INC_SAT(val) (val = ((val)+1 > (val)) ? (val)+1 : (val))

10、返回数组元素的个数

#define ARR_SIZE(a) ( sizeof((a)) / sizeof((a[0])) )

关于嵌套宏的使用

--------------短小结论----------------------
涉及到宏定义展开顺序的知识，如果宏替换以# ##为前缀，则由外向内展开

 #define f(x) #x //结果将被扩展为由实际参数替换该参数的带引号的字符串
 #define b(x) a##x //连接实际参数
 #define ac hello
 int main(void)
 {
     f(b(c))//display "b(c)"
 }
1234567

如果最外层p（x）宏替换不以# ##为前缀，则由内向外展开

#define f(x) #x
#define p(x) f(x)
#define b(x) a##x
#define ac hello
int main(void)
{
    p(b(c))// display "hello"
    return 0;
}
123456789

问题：下面通过宏定义实现一个可以指定前缀的字符串。
PREFIX+".%d"

方法1：使用#运算符。出现在宏定义中的#运算符把跟在其后的参数转换成一个字符串。有时把这种用法的#称为字符串化运算符。

#include<cstdio>
#define PREX 1.3.6
#define FORMAT(n) #n".%d\n"

int main()
{
	int ival = 246;
	printf(FORMAT(PREX), ival);// PREX.246	
	return 0;
}
12345678910

但是输出结果是：PREX.246，和预期的结果不一样，宏PREX作为宏FORMAT的参数并没有替换。那么如何让FORMAT宏的参数可以替换呢？
首先，C语言的宏是允许嵌套的，其嵌套后，一般的展开规律像函数的参数一样：先展开参数，再分析函数，即由内向外展开。但是，注意：
(1) 当宏中有#运算符时，参数不再被展开；
(2) 当宏中有##运算符时，则先展开函数，再展开里面的参数；

PS: ##运算符用于把参数连接到一起。预处理程序把出现在##两侧的参数合并成一个符号（非字符串）。

方法2：修改宏定义的格式，再添加一个中间宏TMP(x)实现对参数的替换，然后再替换为最终想要的字符串。

#define PREX 1.3.6
#define FORMAT(x) TMP(x)
#define TMP(x) #x".%d\n"

int main()
{
	int ival = 246;
	printf(FORMAT(PREX), ival);// 1.3.6.246	
	return 0;
}
12345678910

嵌套宏在某些情况下还是有一定的用处，但是我可能更愿意定义一个函数宏来完成上面这个工作：

#include <cstdio>
#define FORMAT_FUN(szPrex, szFormat) do { \
	char szTmp[128] = {0}; \
	_snprintf(szTmp, sizeof(szTmp)-1, "%s", szFormat); \
	_snprintf(szFormat, sizeof(szFormat)-1, "%s%s", szPrex, szTmp); \
} while(0); \
const char *szPrex = "1.3.6";

int main()
{
	int ival = 246;
	char szFormat[128] = ".%d\n";
	FORMAT_FUN(szPrex, szFormat);	
	//printf("%s\n", szFormat);
	printf(szFormat, ival);// 1.3.6.246	 
	return 0;
}
1234567891011121314151617

举几个关于宏嵌套用法的例子：

Ex. 1

#include <cstdio>
#define TO_STRING2(x) #x
#define TO_STRING(x) TO_STRING1(x)
#define TO_STRING1(x) #x
#define PARAM(x) #x
#define ADDPARAM(x) INT_##x

int main()
{
	const char *str = TO_STRING(PARAM(ADDPARAM(1)));
	printf("%s\n",str);
	str = TO_STRING2(PARAM(ADDPARAM(1)));
	printf("%s\n",str);
	return 0;
}
/*
output:
"ADDPARAM(1)"
PARAM(ADDPARAM(1))
*/

Ex. 2
#include <stdio.h>
#define TO_STRING2(x) a_##x
#define TO_STRING(x) TO_STRING1(x)
#define TO_STRING1(x) #x
#define PARAM(x) #x
#define ADDPARAM(x) INT_##x

int main()
{
	const char *str = TO_STRING(TO_STRING2(PARAM(ADDPARAM(1))));
	printf("%s\n",str);

	return 0;
}
/*
VS2010 output:
a_PARAM(ADDPARAM(1))
GCC 4.3.2 output:
a_PARAM(INT_1)
*/
1234567891011121314151617181920212223242526272829303132333435363738394041424344

注意：例子2的代码分别在不同的编译器上输出结果不相同。这是为什么呢？

C99_TC3
6.10.3.1 Argument substitution
After the arguments for the invocation of a function-like macro have been identified, argument substitution takes place. Aparameter in the replacement list, unless preceded by a # or ## preprocessing token or followed by a ## preprocessing token (see below), is replaced by the corresponding argument after all macros contained therein have been expanded. Before being substituted, each argument’s preprocessing tokens are completely macro replaced as if they formed the rest of the preprocessing file; no other preprocessing tokens are available.
除非替换序列中的形式参数的前面有一个#符号，或者其前面或后面有一个##符号，否则，在插入前要对宏调用的实际参数记号进行检查，并在必要时进行扩展。

改为：

#include <stdio.h>
#define TO_STRING2(x) a_##x
#define TO_STRING(x) TO_STRING1(x)
#define TO_STRING1(x) T(x)
#define T(x) #x
#define PARAM(x) #x
#define ADDPARAM(x) INT_##x

int main()
{
	const char *str = TO_STRING(TO_STRING2(PARAM(ADDPARAM(1))));
	printf("%s\n",str);

	return 0;
}
/*
VS2010 output:
a_PARAM(INT_1)
GCC 4.3.2 output:
a_PARAM(INT_1)
(1) 对TO_STRING的参数TO_STRING2(...)进行检查替换，生成标记a_PARAM(ADDPARAM(1))
(2) 对TO_STRING1的参数a_PARAM(ADDPARAM(1))进行检查替换，生成标记a_PARAM(INT_1)
(3) 对T的参数a_PARAM(INT_1)进行检查替换，生成字符串"a_PARAM(INT_1)"
*/

Ex. 3
#include <stdio.h>

int ival = 0;
#define A(x) printf("%d\n", ival+=1);
#define B(x) printf("%d\n", ival+=2);
#define C() printf("%d\n", ival+=3);


int main()
{
	A(B(C()));
	printf("%d\n", ival);// ?, 1

	return 0;
}
1234567891011121314151617181920212223242526272829303132333435363738394041

补充知识：
The C Programming Language, Second Edition
P.205 预处理

(1) 预处理器执行宏替换、条件编译以及包含指定的文件。
(2) 以#开头的命令行（"#"前可以有空格），就是预处理器处理的对象。
(3) 这些命令行的语法独立于语言的其他部分，它们可以出现在任何地方，其作用可延续到所在翻译单元的末尾（与作用域无关）。
(4) 行边界是有实际意义的。每一行都将单独进行分析。

关于#和##在C语言的宏中，#的功能是将其后面的宏参数进行字符串化操作（Stringfication），简单说就是在对它所引用的宏变量 通过替换后在其左右各加上一个双引号。比如下面代码中的宏：

#define WARN_IF(EXP)     /
     do{ if (EXP)     /
             fprintf(stderr, "Warning: " #EXP "/n"); }    /
     while(0)

那么实际使用中会出现下面所示的替换过程：

WARN_IF (divider == 0);

被替换为


do {
  
     if (divider == 0)
fprintf(stderr, "Warning" "divider == 0" "/n");
} while(0);

这样每次divider（除数）为0的时候便会在标准错误流上输出一个提示信息。

而##被称为连接符（concatenator），用来将两个Token连接为一个Token。注意这里连接的对象是Token就行，而不一定 是宏的变量。比如你要做一个菜单项命令名和函数指针组成的结构体的数组，并且希望在函数名和菜单项命令名之间有直观的、名字上的关系。那么下面的代码就非常实用：

struct command
{
  
char * name;
void (*function) (void);
};

#define COMMAND(NAME) { NAME, NAME ## _command }

// 然后你就用一些预先定义好的命令来方便的初始化一个command结构的数组了：

struct command commands[] = {
  
COMMAND(quit),
COMMAND(help),
...
}

COMMAND宏在这里充当一个代码生成器的作用，这样可以在一定程度上减少代码密度，间接地也可以减少不留心所造成的错误。我们还可以n个##符号连接 n+1个Token，这个特性也是#符号所不具备的。比如：

#define LINK_MULTIPLE(a,b,c,d) a##_##b##_##c##_##d

typedef struct _record_type LINK_MULTIPLE(name,company,position,salary);
// 这里这个语句将展开为：
// typedef struct _record_type name_company_position_salary;

关于…的使用

…在C宏中称为Variadic Macro，也就是变参宏。比如：

#define myprintf(templt,...) fprintf(stderr,templt,__VA_ARGS__)

// 或者

#define myprintf(templt,args...) fprintf(stderr,templt,args)

第一个宏中由于没有对变参起名，我们用默认的宏__VA_ARGS__来替代它。第二个宏中，我们显式地命名变参为args，那么我们在宏定义中就可以用 args来代指变参了。同C语言的stdcall一样，变参必须作为参数表的最有一项出现。当上面的宏中我们只能提供第一个参数templt时，C标准要求我们必须写成：

myprintf(templt,);

的形式。这时的替换过程为：

myprintf("Error!/n",);

替换为：


fprintf(stderr,"Error!/n",);

这是一个语法错误，不能正常编译。这个问题一般有两个解决方法。首先，GNU CPP提供的解决方法允许上面的宏调用写成：

myprintf(templt);

而它将会被通过替换变成：

fprintf(stderr,"Error!/n",);

很明显，这里仍然会产生编译错误（非本例的某些情况下不会产生编译错误）。除了这种方式外，c99和GNU CPP都支持下面的宏定义方式：

#define myprintf(templt, ...) fprintf(stderr,templt, ##__VAR_ARGS__)

这时，##这个连接符号充当的作用就是当__VAR_ARGS__为空的时候，消除前面的那个逗号。那么此时的翻译过程如下：

myprintf(templt);

被转化为：


fprintf(stderr,templt);

这样如果templt合法，将不会产生编译错误。

错误的嵌套－Misnesting

宏的定义不一定要有完整的、配对的括号，但是为了避免出错并且提高可读性，最好避免这样使用。

由操作符优先级引起的问题－Operator Precedence Problem

由于宏只是简单的替换，宏的参数如果是复合结构，那么通过替换之后可能由于各个参数之间的操作符优先级高于单个参数内部各部分之间相互作用的操作符优先级，如果我们不用括号保护各个宏参数，可能会产生预想不到的情形。比如：

#define ceil_div(x, y) (x + y - 1) / y

那么

a = ceil_div( b & c, sizeof(int) );

将被转化为：

a = ( b & c   + sizeof(int) - 1) / sizeof(int);
// 由于+/-的优先级高于&的优先级，那么上面式子等同于：
a = ( b & (c + sizeof(int) - 1)) / sizeof(int);

这显然不是调用者的初衷。为了避免这种情况发生，应当多写几个括号：

#define ceil_div(x, y) (((x) + (y) - 1) / (y))

消除多余的分号－Semicolon Swallowing

通常情况下，为了使函数模样的宏在表面上看起来像一个通常的C语言调用一样，通常情况下我们在宏的后面加上一个分号，比如下面的带参宏：

MY_MACRO(x);

但是如果是下面的情况：

#define MY_MACRO(x) {/
/* line 1 *//
/* line 2 *//
/* line 3 */ }

//...

if (condition())
MY_MACRO(a);
else
{...}

这样会由于多出的那个分号产生编译错误。为了避免这种情况出现同时保持MY_MACRO(x);的这种写法，我们需要把宏定义为这种形式：

#define MY_MACRO(x) do {
  
/* line 1 *//
/* line 2 *//
/* line 3 */ } while(0)

这样只要保证总是使用分号，就不会有任何问题。

Duplication of Side Effects

这里的Side Effect是指宏在展开的时候对其参数可能进行多次Evaluation（也就是取值），但是如果这个宏参数是一个函数，那么就有可能被调用多次从而达到不一致的结果，甚至会发生更严重的错误。比如：

#define min(X,Y) ((X) > (Y) ? (Y) : (X))

//...

c = min(a,foo(b));

这时foo()函数就被调用了两次。为了解决这个潜在的问题，我们应当这样写min(X,Y)这个宏：

#define min(X,Y) ({/
typeof (X) x_ = (X);/
typeof (Y) y_ = (Y);/
(x_ < y_) ? x_ : y_; })

({…})的作用是将内部的几条语句中最后一条的值返回，它也允许在内部声明变量（因为它通过大括号组成了一个局部Scope）

小熊coder

关注

29
点赞
踩
113

收藏

觉得还不错? 一键收藏
打赏
5
评论
C语言define高级用法大全

今天在看代码时，突然发现很多define的用法看不懂，故在此总结一下，顺便吐槽一下，C语言的宏复杂起来真的很难看懂。不信的去看下这个的源码：【C语言开源库】lw_oopc：轻量级的C语言面向对象编程框架一、宏的定义与撤销需要注意的是：（1）宏定义应注意添加括号，这样语义会比较清晰。（2）使用#undef可以撤销宏定义。（3）引号中的宏定义不会被替换。（4）宏定义的宏名必须是合法的标识符。（5）宏定义中单、双引号必须成对出现。二、带有参数的宏定义需要注意的是：（1）宏调用时参数的个数
复制链接

扫一扫