c语言宏定义技巧
简述C语言宏定义的使用
简述C语言宏定义的使用1 概述在工程规模较小，不是很复杂，与硬件结合紧密，要求移植性的时候，可采用宏定义简化编程，增强程序可读性。
当宏作为常量使用时，C程序员习惯在名字中只使用大写字母。
但是并没有如何将用于其他目的的宏大写的统一做法。
由于宏（特别是带参数的宏）可能是程序中错误的来源，所以一些程序员更喜欢使用大写字母来引起注意。
1.简单宏定义无参宏的宏名后不带参数,其定义的一般形式为:#define 标识符字符串// 不带参数的宏定义#define MAX 10注意：不要在宏定义中放置任何额外的符号，比如"="或者尾部加";"使用#define来为常量命名一些优点：•程序会更易读。
一个认真选择的名字可以帮助读者理解常量的意义；•程序会更易于修改。
我们仅需要改变一个宏定义，就可以改变整个程序中出现的所有该常量的值；•可以帮助避免前后不一致或键盘输入错误；•控制条件编译；•可以对C语法做小的修改；1.带参数的宏带参数的仍要遵循上述规则，区别只是宏名后面紧跟的圆括号中放置了参数，就像真正的函数那样。
#define <宏名>(<参数列表>) <宏体>注意参数列表中的参数必须是有效的c标识符，同时以,分隔算符优先级问题：#define COUNT(M) M*Mint x=5;print(COUNT(x+1));print(COUNT(++X));//结果输出：11 和42 而不是函数的输出36注意：•预编译器只是进行简单的文本替换，COUNT(x+1)被替换成COUNT(x+1x+1)，5+15+1=11，而不是36•CUNT(++x)被替换成++x*++x即为67=42，而不是想要的66=36，连续前置自加加两次解决办法：•用括号将整个替换文本及每个参数用括号括起来print(COUNT((x+1));•即便是加上括号也不能解决第二种情况，所以解决办法是尽量不使用++，-等符号；分号吞噬问题：#define foo(x) bar(x); baz(x)假设这样调用：if (!feral)foo(wolf);将被宏扩展为：if (!feral)bar(wolf);baz(wolf);==baz(wolf);==,不在判断条件中，显而易见，这是错误。
c 宏定义 用法
c 宏定义用法
C语言中的宏定义是一种预处理指令，用于在编译之前将一些常量、函数、代码块等定义为一个标识符，方便代码的编写与管理。
宏定义的格式为：#define 标识符替换文本。
其中，标识符可以是任何合法的C语言标识符，替换文本可以是任何合法的C语句，包括常量、表达式、函数等。
宏定义有以下几种用法：
1. 定义常量：可以用宏定义来定义一些常量，例如#define PI 3.1415926，这样在代码中使用PI就相当于使用了常量3.1415926。
2. 定义函数：可以用宏定义来定义一些简单的函数，例如
#define ADD(a,b) (a+b)，这样在代码中使用ADD(x,y)就相当于使用了函数x+y。
3. 定义代码块：可以用宏定义来定义一些代码块，例如#define SQUARE(x) (x*x)，这样在代码中使用SQUARE(a)就相当于使用了a*a。
4. 定义条件编译：可以用宏定义来定义一些条件编译语句，例如#define DEBUG，这样在代码中使用#ifdef DEBUG和#endif就可以编写一些只在调试模式下才执行的代码。
需要注意的是，宏定义是一种简单的文本替换，因此可能会导致一些不可预期的问题，例如宏定义中的参数没有被正确使用时，就可能会导致编译错误或者逻辑错误。
同时，宏定义也不适用于一些复杂的操作，例如大量的循环、递归等，因为这可能会导致代码体积变大、可读性变差等问题。
因此，在使用宏定义时需要谨慎。
C语言宏定义技巧
C语言宏定义技巧C语言中的宏定义是预处理指令之一，用来替换或扩展代码中的标识符。
宏定义是C语言中一种非常有用的技巧，可以简化代码，提高代码的可读性和可维护性。
下面是一些常用的宏定义技巧。
1. 定义常量：可以使用宏定义来定义常量，提高代码的可读性。
例如，可以使用下面的宏定义来定义一个pi常量：``````这样，每次在代码中需要使用pi的时候就可以直接使用宏定义名称来代替。
2.定义函数：宏定义还可以用来定义函数。
虽然宏定义的语法和函数的语法不同，但是宏定义在代码中起到的作用和函数很相似。
例如，可以使用下面的宏定义来定义一个求平方的函数：```#define SQUARE(x) (x)*(x)```这样，每次在代码中需要求一个数的平方的时候，可以使用SQUARE 宏来代替函数调用。
3.简化代码：宏定义可以用来简化代码，减少代码的重复性。
例如，可以使用下面的宏定义来简化代码中的计算公式：```#define AREA(length, width) (length)*(width)```这样，每次计算面积的时候，可以使用AREA宏来代替计算公式，提高代码的可读性和简洁性。
4.调试信息：宏定义还可以用来输出调试信息，方便调试程序。
例如，可以使用下面的宏定义来打印调试信息：```#define DEBUG_MSG(msg) printf("%s\n", msg)```这样，每次需要输出调试信息的时候，可以使用DEBUG_MSG宏来代替printf语句。
5.条件编译：宏定义还可以用来实现条件编译，根据不同的条件选择不同的代码。
例如，可以使用下面的宏定义来实现条件编译：```#define ENABLE_FEATURE_A#ifdef ENABLE_FEATURE_A//执行特性A的代码#else//执行其他代码#endif```这样，根据是否定义了ENABLE_FEATURE_A宏，可以选择执行不同的代码。
C语言宏定义技巧与示例
C语言宏定义技巧与示例宏定义在C语言中被广泛应用，能够方便地定义常量、函数等，提高代码的可读性和重用性。
本文将介绍一些C语言宏定义的技巧，并提供相应的示例。
一、宏定义的基本语法在C语言中，宏定义使用`#define`关键字，其基本语法为：```c#define 宏名值```其中，宏名为用户自定义的标识符，值可以是常量、表达式、函数等。
二、宏定义的常见用途1. 定义常量宏定义可以方便地定义常量，例如：```c#define PI 3.14159#define MAX_SIZE 100```这样在代码中使用常量时只需使用宏名即可，提高了代码的可读性。
2. 定义函数宏定义还可以用来定义函数，例如：```c#define SQUARE(x) ((x) * (x))```该宏定义了一个计算平方的函数。
在代码中，可直接使用该宏名加参数的方式调用该函数，例如`SQUARE(2)`将返回4。
3. 实现条件编译宏定义可以与条件编译指令配合使用，根据不同条件选择性地编译或忽略部分代码。
例如：```c#define DEBUG#ifdef DEBUG// 调试代码#else// 发布代码#endif```在进行调试时，定义了`DEBUG`宏，调试代码将会被编译；而在发布时，`DEBUG`宏未定义，调试代码将被忽略。
4. 定义复杂的表达式宏定义也可以用于定义复杂的表达式，例如：```c#define MAX(x, y) ((x) > (y) ? (x) : (y))```该宏定义了一个返回两个数中较大值的表达式。
在代码中，可以通过`MAX(3, 5)`直接得到5。
三、宏定义的技巧1. 使用括号确保正确的优先级在宏定义中使用括号，可以确保表达式的优先级得到正确的解释。
例如：```c#define SQUARE(x) ((x) * (x))```在宏定义中，将参数和运算都用括号括起来，避免出现意外的错误。
2. 避免多次求值在宏定义时，应注意避免多次对参数进行求值。
C语言中的宏定义用法
C语言中的宏定义用法宏定义是C语言中一种重要的预处理指令，通过宏定义可以为一些常用的代码片段或数值指定名称，方便程序开发和维护。
本文将介绍C语言中宏定义的用法和注意事项。
首先，在C语言中，宏定义使用“#define”关键字进行定义，其语法格式为：```#define 宏名称值```其中，宏名称是自定义的标识符，可以是任意有效的变量名或符号；值可以是任意的表达式、常量或代码片段。
通过宏定义，我们可以将一些重复使用的代码片段定义为宏，以提高代码的重用性和可读性。
在使用宏定义时，需要注意以下几点：1. 宏定义不需要分号结尾，直接写在宏定义行即可。
2. 宏名称一般使用大写字母表示，以区分于普通变量。
3. 宏定义的值可以是任意合法的C语句，但最好使用括号将其括起来，防止优先级问题。
4. 宏定义中可以使用参数，以实现不同场景下的值替换。
除了定义普通的宏之外，C语言中还有一种特殊的宏定义“#define MAX(a, b) ((a) > (b) ? (a) : (b))”，这种宏定义被称为宏函数，可以实现简单的函数功能。
宏函数通常使用括号将参数括起来，以确保表达式的正确性。
另外，C语言中还有一些系统预定义的宏，如“__FILE__”表示当前文件名，“__LINE__”表示当前行号，“__FUNCTION__”表示当前函数名等。
这些宏可以在调试和错误提示时起到一定的作用，方便程序员定位问题。
在使用宏定义时，需要注意一些潜在的问题，如：1. 宏定义的替换是简单的文本替换，可能会产生一些意外的结果。
2. 宏定义带来的代码重复可能会增加代码的长度，降低代码的可读性。
3. 在调试时，宏定义会隐藏实际代码逻辑，导致调试困难。
综上所述，C语言中的宏定义是一种方便而强大的工具，可以提高代码的可维护性和可读性。
在使用宏定义时，需要注意语法规范和潜在的问题，以充分发挥其优势。
通过合理地运用宏定义，可以使程序更加简洁高效，提升开发效率。
C语言的预处理指令与宏定义优化
C语言的预处理指令与宏定义优化概述C语言是一种广泛使用的编程语言，其灵活性和高效性使得它成为许多开发者的首选语言。
在C语言中，预处理指令和宏定义是两个重要的概念，可用于优化代码和增加代码的可读性。
本文将介绍C语言的预处理指令和宏定义，并探讨如何利用它们进行代码优化。
什么是预处理指令？预处理指令是在编译之前执行的一系列指令，它们用于对源代码进行一些处理，以产生最终的编译代码。
预处理指令以“#”字符开头，并且在一行中独立存在。
预处理指令是在编译器编译源代码之前，由预处理器（preprocessor）负责处理的。
预处理指令的作用预处理指令有多种作用，主要包括以下几个方面：1.宏定义（Macro definition）：通过宏定义，可以将一组代码片段用一个名字代替，从而减少重复编码，提高代码的可读性。
宏定义可以带有参数，使得代码更加灵活。
2.文件包含（File inclusion）：通过预处理指令“#include”，可以在源代码中插入其他文件的内容，这样可以将代码模块化，提高代码的易读性和可维护性。
3.条件编译（Conditional compilation）：通过预处理指令“#ifdef”、“#ifndef”、“#endif”等，可以根据条件来选择性地编译一部分代码，从而实现不同的功能组合。
4.符号替换（Symbol substitution）：通过预处理指令“#define”，可以将一个符号替换为另一个符号，从而可以在源代码中使用更加易懂的符合语义的名称。
什么是宏定义？宏定义是一种在代码中定义一个标识符的方法，它可以被替换为一段代码或一个值。
宏定义以“#define”关键字开头，后面是宏的名称和它所代表的值或代码。
宏定义以“#define”关键字开头，后面是宏的名称和它所代表的值或代码。
在程序中，当遇到该宏的名称时，预处理器会将其替换为宏的值或代码。
宏定义的优化技巧使用宏定义可以提高代码的可读性和可维护性，同时也可以优化代码的性能和减少代码的长度。
c+宏定义的使用方法
C++中的宏定义使用方法如下：
1. 宏定义使用 #define 指令，其格式为：
```c
#define 宏名(参数列表) 宏体
```
其中，宏名通常全部大写，以区别于变量名和函数名。
参数列表是可选的，用于指定宏的参数。
宏体是宏的替换文本，可以是任何有效的C++代码。
2. 宏定义的一般形式为：
```c
#define 宏名替换文本
```
其中，宏名可以是任何标识符，替换文本可以是任何有效的C++代码。
例如：
#define PI 3.14159
```
3. 宏定义可以带有参数，例如：
```c
#define SQUARE(x) ((x) * (x))
```
其中，SQUARE是一个带有参数的宏，它计算x的平方。
在宏定义中，参数列表为(x)，宏体为((x) * (x))。
在宏替换时，参数x将被替换为实际参数。
例如：
```c
int y = SQUARE(5); // y = (5) * (5) = 25
```
4. 宏定义可以嵌套使用，例如：
```c
#define MIN(a, b) ((a) < (b) ? (a) : (b))
其中，MIN是一个带有两个参数的宏，它计算两个数中的较小值。
在宏定义中，使用了条件运算符和嵌套的宏调用。
在宏替换时，将会被展开为实际的代码。
例如：
```c
int x = 10, y = 20;
int z = MIN(x, y); // z = ((x) < (y) ? (x) : (y)) = 10
```。
c语言宏定义用法(一)
c语言宏定义用法(一)C语言宏定义C语言中的宏定义是一个预处理指令，可以用来在编译前替换文本。
宏定义可以提高代码的可维护性和重用性。
下面是一些宏定义的常用用法：宏定义基础•定义常量#define PI在程序中使用PI，编译器会自动将其替换为``。
•定义函数#define MAX(a, b) ((a) > (b) ? (a) : (b))可以使用该宏定义来比较两个数的大小，例如int max = MAX(3, 5);得到max的值为5。
宏定义的高级用法•带参数的宏#define SQUARE(x) ((x) * (x))可以使用该宏定义来计算一个数的平方，例如int result = SQUARE(4);得到result的值为16。
•带可变参数的宏#define PRINTF(format, ...) printf(format, __VA_ARGS__)可以使用该宏定义来代替printf函数，例如PRINTF("Hello, %s!\n", "World");会输出Hello, World!。
•条件编译#ifdef DEBUGprintf("Debug mode enabled.\n");#elseprintf("Debug mode disabled.\n");#endif可以使用该宏定义来根据是否定义了DEBUG来选择不同的代码执行路径。
注意事项•宏定义不是函数宏定义只是简单的文本替换，不会进行类型检查和作用域限制，容易出错。
•宏定义中的括号在宏定义中，为了保证优先级，需要使用括号将参数和运算表达式括起来。
•宏定义中的副作用由于宏定义是纯文本替换，可能会导致一些意想不到的副作用，例如：#define SQUARE(x) ((x) * (x))int result = SQUARE(5++); // 编译错误在这个例子中，5++会被替换为5 + 1，导致编译错误。
c语言中宏定义
c语言中宏定义宏定义是C语言中一种非常重要的特性，通过宏定义可以简化代码，提高代码的可维护性和可读性。
在C语言中，宏定义是通过#define指令来实现的，可以定义常量、函数宏以及条件编译等。
首先，我们来看一下如何定义常量宏。
在C语言中，我们可以使用#define指令定义常量，例如：#define PI 3.14159。
这样，每次在代码中使用PI时，编译器会将其替换为3.14159。
常量宏的定义格式为#define 宏名值。
除了定义常量，宏定义还可以用来定义函数宏。
函数宏是一种宏定义，可以像函数一样接受参数，并返回一个值。
例如，我们可以定义一个计算平方的函数宏：#define SQUARE(x) ((x) * (x))。
在使用时，可以像函数一样传入参数，编译器会将其替换为对应的表达式。
另外，宏定义还可以用于条件编译，即根据条件编译指令来决定编译哪些代码。
例如，我们可以使用宏定义来控制代码的编译，如下所示：#ifdef DEBUGprintf("Debug mode\n");#endif在这段代码中，如果定义了DEBUG宏，则会打印“Debug mode”，否则不会打印。
条件编译可以根据宏定义的真假来选择性地编译代码，提高代码的灵活性和可移植性。
此外，宏定义还可以用于定义一些特定的编译器指令，如调试信息、优化等。
通过宏定义，我们可以根据不同的编译选项定义不同的宏，以达到不同的编译效果。
总的来说，宏定义是C语言中一种非常有用的特性，可以简化代码、提高代码的可维护性和可读性，同时还可以用于条件编译、函数宏等方面。
合理地使用宏定义，可以使代码更加灵活、高效。
希望以上内容对您有所帮助。
如果有其他问题，欢迎继续提问。
感谢阅读！。
c语言之带参数的宏定义
c语⾔之带参数的宏定义1.带参数的宏定义中，宏名和新参表之间不能有空格，2.在带参数的宏定义中，形参参数不分配内存单元，因此不必作类型定义。
⽽宏调⽤中的实参有具体值，要⽤它去代换形参，因此必须作类型说明。
#include<stdio.h>#include<iostream>#define MAX(a,b) (a>b)?a:bint main() {int x, y, max;x = 2;y = 3;max = MAX(x,y);printf("%d\n", max);system("pause");return0;}3.在宏定义中的形参是标识符，⽽宏调⽤中实参可以是表达式。
4.在宏定义中，字符串内的形参通常要⽤括号括起来以避免出错。
5.带参的宏和代餐函数类似，但本质不同，除此之外，把同⼀表达式⽤函数处理和⽤宏处理两者的结果有可能不同。
普通函数：#include<stdio.h>#include<iostream>int SQ(int y) {return ((y) * (y));}int main() {int i = 1;int SQ(int y);while (i <= 5) {printf("%d ", SQ(i++));}printf("\n");system("pause");return0;}输出：宏定义：#include<stdio.h>#include<iostream>#define SQ(y) (y)*(y)int main() {int i = 1;while (i <= 5) {printf("%d ", SQ(i++));}printf("\n");system("pause");return0;}输出：为什么结果不同呢？这是因为普通函数调⽤时，实参传给形参的是值，⽽在宏定义时，要⽤表达式进⾏替换，即(i++)*(i++)，所以I++会被执⾏两次。
C语言宏定义详解
C语言宏定义详解我们可能要定义很多常量( 不管是放在源文件还是头文件 ),那么我们有时考虑定义某个常量时,我们就必须返回检查原来此常量是否定义,但这样做很麻烦.if defined宏正是为这种情况提供了解决方案.举个例子,如下:#define ....#define ....................#define a 100.......此时，我们要检查a是否定义（假设我们已经记不着这点了）,或者我们要给a一个不同的值，就加入如下句子#if defined a#undef a#define a 200#endif上述语句检验a是否被定义，如果被定义，则用#undef语句解除定义，并重新定义a为200 同样，检验a是否定义：#ifndef a //如果a没有被定义#define a 100#endif以上所用的宏中：#undef为解除定义，#ifndef是if not defined的缩写，即如果没有定义。
这就是#if defined 的唯一作用常用宏定义总结*pclint////////////////////////////////// #include <stdio.h>////////////////////////////////#define VPLS_EXT_DEBUG 1#if VPLS_EXT_DEBUG#define _VE_DEBUG(msg...) printf("[VPLS_DEBUG] %s,%d => ",__FILE__, __LINE__);printf(msg);printf("\r\n")#else#define_VE_DEBUG(x1,x2) (void)(x1),(void)(x2)#endif调用直接写为_VE_DEBUG("XXXXX %d",adb)开关关闭后这句直接失效//////////////////////////////main(void){ int a,b,c,d; a = b = c = d = 9;_BUG("a = %d,b = %d,c = %d,d = %d\n",a,b,c,d);}#define assert(e)\ ((void)((e) || fprintf(stderr,"line %d: 'asserterror!'\n",__LINE__)))////////////////////////////////////__attribute__ 作用- -__attribute__ 是GCC的关键字，描述变量的属性。
c语言数组宏定义
在C语言中，数组宏定义是一种非常有用的工具，它允许我们使用预处理器指令`#define`来定义一个宏，这个宏可以代表一个数组。
这种方式在某些情况下非常有用，例如当我们需要频繁地使用相同大小的数组，或者我们希望减少代码的冗余时。
下面是一个简单的例子来说明如何使用宏定义来定义一个数组：```c#include <stdio.h>#define ARRAY_SIZE 6#define ARRAY(type) type array[ARRAY_SIZE]int main() {ARRAY(int) values[ARRAY_SIZE] = {1, 2, 3, 4, 5, 6};for(int i = 0; i < ARRAY_SIZE; i++) {printf("%d ", values[i]);}return 0;}```这个例子中，我们首先定义了一个宏`ARRAY_SIZE`，它表示数组的大小。
然后我们使用`#define`定义了一个名为`ARRAY`的宏，它接受一个类型参数`type`并返回一个数组。
在`main`函数中，我们创建了一个整数类型的数组`values`并初始化了它。
让我们详细地解释一下这个例子：* `#define ARRAY_SIZE 6`：这行代码定义了一个宏`ARRAY_SIZE`，其值为6。
这意味着我们可以使用`ARRAY_SIZE`作为其他宏的大小参数。
* `#define ARRAY(type) type array[ARRAY_SIZE]`：这行代码定义了一个名为`ARRAY`的宏，它接受一个类型参数`type`并返回一个数组。
这个宏返回的数组名为`array`，大小为`ARRAY_SIZE`。
这意味着我们可以使用这个宏来定义任何大小的数组。
* 在`main`函数中，我们创建了一个名为`values`的数组，其类型为整数，大小为6。
C语言宏的使用方法和注意事项
C语言宏的使用方法和注意事项C语言宏是一种在程序中定义的预处理指令，它可以将一段代码片段替换为另一段代码片段，从而实现代码的复用和简化。
宏的使用方法和注意事项对于C语言程序员来说非常重要，下面将介绍一些常见的使用方法和需要注意的问题。
一、宏的基本语法和使用方法在C语言中，使用宏需要使用宏定义指令`#define`。
宏定义的基本语法如下：```#define 宏名替换文本```宏名是用户自定义的标识符，替换文本是要替换的代码片段。
宏定义通常放在程序的开头或者头文件中。
宏的使用方法非常简单，只需要在代码中使用宏名即可。
在编译时，预处理器会将宏名替换为对应的代码片段。
例如：```#define PI 3.1415926float r = 5.0;float area = PI * r * r;```在上面的代码中，宏定义了一个常量PI，它的值为3.1415926。
在计算圆的面积时，直接使用了宏PI，而不需要写出具体的数值。
二、宏的参数和参数化宏宏不仅可以替换代码片段，还可以接受参数。
定义带参数的宏需要在宏名后面加上参数列表，参数列表使用圆括号括起来。
例如：```#define MAX(a, b) ((a) > (b) ? (a) : (b))int max = MAX(10, 20);```在上面的代码中，宏定义了一个带两个参数的宏MAX，它返回两个参数中的较大值。
在使用宏时，直接传入具体的数值，宏会自动进行参数替换和计算。
参数化宏的使用可以大大提高代码的灵活性和复用性。
通过定义不同的参数，可以轻松实现不同的功能。
但是需要注意，宏的参数是没有类型的，它只是简单的文本替换，所以在使用宏时需要注意参数的类型和表达式的正确性。
三、宏的注意事项在使用宏时，需要注意以下几个问题：1. 宏的替换文本不要使用分号。
因为宏的替换是简单的文本替换，如果在替换文本中加上分号，会导致使用宏的地方出现多余的分号，从而引发编译错误。
c语言宏定义技巧
byte; word; dword; uint1; uint2; uint4; int1; int2; int4; sint31; sint15; sint7;
/* Unsigned 8 bit value type. */ /* Unsinged 16 bit value type. */ /* Unsigned 32 bit value type. */ /* Unsigned 8 bit value type. */ /* Unsigned 16 bit value type. */ /* Unsigned 32 bit value type. */ /* Signed 8 bit value type. */ /* Signed 16 bit value type. */ /* Signed 32 bit value type. */ /* Signed 32 bit value */ /* Signed 16 bit value */ /* Signed 8 bit value */
c 语言宏定义技巧
＃i nclude<climits> using namespace std; #define STR(s) #s #define CONS(a,b) int(a##e##b) int main() { printf(STR(vck)); // 输出字符串"vck" printf("%d\n", CONS(2,3)); // 2e3 输出:2000 return 0; } 二、当宏参数是另一个宏的时候 需要注意的是凡宏定义里有用'#'或'##'的地方宏参数是不会再展开. 1, 非'#'和'##'的情况 #define TOW (2) #define MUL(a,b) (a*b) printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW)); 这行的宏会被展开为： printf("%d*%d=%d\n", (2), (2), ((2)*(2))); MUL 里的参数 TOW 会被展开为(2). -------------------------------------------------------------------------------2, 当有'#'或'##'的时候 #define A (2) #define STR(s) #s #define CONS(a,b) int(a##e##b) printf("int max: %s\n", STR(INT_MAX)); // INT_MAX ＃i nclude<climits> 这行会被展开为： printf("int max: %s\n", "INT_MAX"); printf("%s\n", CONS(A, A)); // compile error 这一行则是： printf("%s\n", int(AeA)); INT_MAX 和 A 都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏. 加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到 正确的宏参数. #define A (2) #define _STR(s) #s #define STR(s) _STR(s) // 转换宏 #define _CONS(a,b) int(a##e##b) #define CONS(a,b) _CONS(a,b) // 转换宏 printf("int max: %s\n", STR(INT_MAX)); // INT_MAX,int 型的最大值，为一个变量 ＃i nclude<climits> 输出为: int max: 0x7fffffff STR(INT_MAX) --> _STR(0x7fffffff) 然后再转换成字符串；
define使用的注意事项
define使用的注意事项
Define是一个在C语言中非常常用的宏定义，它可以用来定义常量、函数、数据类型等。
在使用Define时，需要注意以下几点：
1. 定义常量时，建议使用大写字母。
这样可以方便区分常量和变量，也可以提高代码的可读性。
2. 定义函数时，需要注意函数名和参数的书写。
函数名应该具有描述性，能够清晰地表达函数的作用。
参数的书写应该符合函数的实际需求，不要过多或过少。
3. 定义数据类型时，需要注意数据类型的名称和成员变量的书写。
数据类型的名称应该具有描述性，能够清晰地表达数据类型的作用。
成员变量的书写应该符合数据类型的实际需求，不要过多或过少。
4. 定义多行的宏时，需要使用反斜杠（\）进行换行。
这样可以使代码更加美观，也可以提高代码的可读性。
5. 定义宏时，需要注意宏的作用域。
宏定义的作用域是整个程序，因此需要避免定义与其他变量或函数同名的宏。
6. 定义宏时，需要注意宏的参数。
宏的参数可以是任意类型的表达式，但需要注意参数的书写方式和数量。
7. 定义宏时，需要注意宏的嵌套。
宏可以嵌套使用，但需要注意嵌套
的层数，避免出现过多的嵌套。
8. 定义宏时，需要注意宏的语法。
宏的语法比较灵活，但需要注意语
法的正确性，避免出现语法错误。
总之，在使用Define时，需要注意代码的规范性和可读性，避免出现不必要的错误和混乱。
同时，也需要不断学习和掌握Define的使用技巧，提高代码的质量和效率。
C语言宏定义全解析
C语言宏定义全解析C语言宏定义是C语言中一种非常重要的特性，它可以将一段代码或者一种特定的操作封装成一个宏，方便在程序中多次使用。
宏定义在代码的编写过程中起到了简化代码、提高代码的可读性和可维护性的作用。
本文将详细解析C语言宏定义的相关知识，包括宏定义的基本语法、宏定义的特点、宏定义的使用技巧和注意事项等。
一、宏定义的基本语法C语言宏定义的基本语法为：#define 宏名字符串其中，宏名是宏定义的标识符，字符串是需要定义的内容。
在宏定义中，为了增加可读性和减少错误，通常要求宏名全大写。
字符串可以是单个代码行，也可以是多行代码，多行代码需要使用反斜杠(\)进行换行。
示例：#define MAX_VALUE 100#define SQUARE(x) ((x) * (x))#define PRINT_INT(x) printf("%d\n", x)二、宏定义的特点1. 宏定义是在预处理阶段进行的，不占用运行时的内存空间。
2. 宏定义可以定义常量、表达式或函数。
3. 宏定义不会进行类型检查，只是简单的文本替换。
4. 宏定义可以嵌套使用，宏会被递归地展开。
5. 宏定义的作用域为定义后的位置至文件结束或宏重新定义前。
三、宏定义的使用技巧1. 定义宏时需要遵守一定的规范，充分考虑到宏展开后的语法正确性。
2. 在宏定义中使用括号，尤其是在表达式中使用，可以避免优先级问题带来的错误。
3. 在宏定义中使用do-while(0)结构，可以解决宏在某些特定使用场景下的问题。
4. 使用宏时要注意参数的类型，宏不会进行类型检查，可能会导致意想不到的错误。
5. 避免定义过多的宏，过多的宏定义会增加代码的复杂性和维护的难度。
四、宏定义的注意事项1. 宏定义不要滥用，只有在确实有必要的情况下才进行宏定义。
2. 注意宏展开后的代码风格，避免出现过长的宏替换代码。
3. 避免使用“#ifdef”、“#else”、“#endif”等预处理指令来控制宏的定义和使用。
c语言宏定义用法规则
c语言宏定义用法规则C语言宏定义是一种C语言中最常使用的技术，它可以将经常使用的长句子等缩短，可以将复杂的语句也变得更加简单。
使用宏定义，可以提高程序的可读性，使程序更加便于维护和修改，并且可以更加高效地使用程序。
一、宏定义的语法形式C语言的宏定义的语法有以下几种格式：1. #define：#define宏定义用于定义字符串宏或符号宏，本质上它就是把特定的字符串或符号，映射到一个相应的宏名称。
例如：#define PI 3.14159293表示宏定义一个PI，其值为3.141592932. #undef：#undef用于取消宏定义，例如：#undef PI表示取消之前定义流程中的PI宏定义；3. #ifdef：#ifdef可以根据宏定义的存在与否，在程序编译时有选择性的执行一段代码，例如：#ifdef PIprintf("PI is define\n");#endif上述代码表示：如果PI的宏定义存在的话，则编译执行printf("PI is define\n")，否则不执行。
C语言宏定义可以使用参数，这些参数可以是函数、符号、字符串或者表达式，它们都可以在宏定义中扮演角色，使用参数可以提高宏的可扩展性，从而提高程序的复用性，简化程序的结构。
1. 宏定义参数的表示参数的格式使用形式参数名称来表示，一般使用字母a~z表示参数，形式参数可以使用多次，但参数名必须是唯一的。
例如：#define MIN(x, y) ((x) < (y))? (x): (y)这是一个使用参数的宏定义示例，其中参数x,y是表示形式参数的名称，宏定义的意思是返回x和y的较小值。
使用宏定义参数需要在宏定义时明确参数的含义，每个参数都必须有明确的含义，有利于后续的维护和修改。
例如：三、C语言宏定义书写规范1. #define是注释符号，使用时要在一行的开头，以#开头，表示此行的内容是宏定义，且宏定义的关键词必须全大写。
【最新精选】c语言宏定义详解
C语言宏定义详解转自：[url]/fengyuruhui/archive/2007/08/16/1747090.aspx[/u rl]原作者不详1,防止一个头文件被重复包含#ifndef COMDEF_H#define COMDEF_H//头文件内容#endif2,重新定义一些类型,防止由于各种平台和编译器的不同,而产生的类型字节数差异,方便移植。
typedef unsigned char boolean; /* Boolean value type. */typedef unsigned long int uint32; /* Unsigned 32 bit value */typedef unsigned short uint16; /* Unsigned 16 bit value */typedef unsigned char uint8; /* Unsigned 8 bit value */typedef signed long int int32; /* Signed 32 bit value */typedef signed short int16; /* Signed 16 bit value */typedef signed char int8; /* Signed 8 bit value *///下面的不建议使用typedef unsigned char byte; /* Unsigned 8 bit value type. */typedef unsigned short word; /* Unsinged 16 bit value type. */typedef unsigned long dword; /* Unsigned 32 bit value type. */typedef unsigned char uint1; /* Unsigned 8 bit value type. */typedef unsigned short uint2; /* Unsigned 16 bit value type. */typedef unsigned long uint4; /* Unsigned 32 bit value type. */typedef signed char int1; /* Signed 8 bit value type. */typedef signed short int2; /* Signed 16 bit value type. */typedef long int int4; /* Signed 32 bit value type. */typedef signed long sint31; /* Signed 32 bit value */typedef signed short sint15; /* Signed 16 bit value */typedef signed char sint7; /* Signed 8 bit value */3,得到指定地址上的一个字节或字#define MEM_B( x ) ( *( (byte *) (x) ) )#define MEM_W( x ) ( *( (word *) (x) ) )4,求最大值和最小值#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )5,得到一个field在结构体(struct)中的偏移量#define FPOS( type, field ) \/*lint -e545 */ ( (dword) &(( type *) 0)-> field ) /*lint +e545 */6,得到一个结构体中field所占用的字节数#define FSIZ( type, field ) sizeof( ((type *) 0)->field )7,按照LSB格式把两个字节转化为一个Word#define FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )8,按照LSB格式把一个Word转化为两个字节#define FLOPW( ray, val ) \(ray)[0] = ((val) / 256); \(ray)[1] = ((val) & 0xFF)9,得到一个变量的地址（word宽度）#define B_PTR( var ) ( (byte *) (void *) &(var) )#define W_PTR( var ) ( (word *) (void *) &(var) )10,得到一个字的高位和低位字节#define WORD_LO(xxx) ((byte) ((word)(xxx) & 255))#define WORD_HI(xxx) ((byte) ((word)(xxx) >> 8))11,返回一个比X大的最接近的8的倍数#define RND8( x ) ((((x) + 7) / 8 ) * 8 )12,将一个字母转换为大写#define UPCASE( c ) ( ((c) >= ''a'' && (c) <= ''z'') ? ((c) - 0x20) : (c) )13,判断字符是不是10进值的数字#define DECCHK( c ) ((c) >= ''0'' && (c) <= ''9'')14,判断字符是不是16进值的数字#define HEXCHK( c ) ( ((c) >= ''0'' && (c) <= ''9'') ||\((c) >= ''A'' && (c) <= ''F'') ||\((c) >= ''a'' && (c) <= ''f'') )15,防止溢出的一个方法#define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))16,返回数组元素的个数#define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )17,返回一个无符号数n尾的值MOD_BY_POWER_OF_TWO(X,n)=X%(2^n) #define MOD_BY_POWER_OF_TWO( val, mod_by ) \( (dword)(val) & (dword)((mod_by)-1) )18,对于IO空间映射在存储空间的结构,输入输出处理#define inp(port) (*((volatile byte *) (port)))#define inpw(port) (*((volatile word *) (port)))#define inpdw(port) (*((volatile dword *)(port)))#define outp(port, val) (*((volatile byte *) (port)) = ((byte) (val)))#define outpw(port, val) (*((volatile word *) (port)) = ((word) (val)))#define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val)))19,使用一些宏跟踪调试A N S I标准说明了五个预定义的宏名。
C语言常用宏定义技巧
#define MEM_W(x) (*((uint16 *)(x)))
注：类似于这种有多个字符串组成的宏定义一定要注意加上“（）”，因为我们知道宏定义只是一种简单的字符替换功能。
4. 求最大值和最小值：
#define MAX(x,y) (((x)>(y))?(x):(y))
constructor
13. 冒泡排序算法的时间复杂度是什么？
O(n^2)
14. 写出float x 与“零值”比较的if语句。
if(x>0.000001&&x<-0.000001)
16. Internet采用哪种网络协议？该协议的主要层次结构？
tcp/ip 应用层/传输层/网络层/数据链路层/物理层
{
FLOPW(ray,val)
}
else
Hale Waihona Puke { } 8. 得到一个变量的地址：
#define B_PTR(var) ((byte *)(void *)&(var))
#define W_PTR(var) ((word *)(void *)&(var))
C语言常用宏定义技巧
2
推荐 C语言常用宏定义技巧
用C语言编程，宏定义是个很重要的编程技巧。用好了宏定义，它可以增强程序的可读性、可移植性、方便性、灵活性等等。
1. 防止一个头文件被重复包含：
#ifndef COMDEF_H
#define COMDEF_H
#define FLOPW(ray,val) do{ (ray)[0]=((val)/256); (ray)[1] =((val)&0xFF);}while(0)
C语言中宏定义的用法与意义
C语言宏定义技巧（常用宏定义）写好C语言，漂亮的宏定义很重要，使用宏定义可以防止出错，提高可移植性，可读性，方便性等等。
下面列举一些成熟软件中常用得宏定义。
1，防止一个头文件被重复包含#ifndef COMDEF_H#define COMDEF_H//头文件内容#endif2，重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。
typedef unsigned char boolean; /* Boolean value type. */typedef unsigned long int uint32; /* Unsigned 32 bit v alue */typedef unsigned short uint16; /* Unsigned 16 bit va lue */typedef unsigned char uint8; /* Unsigned 8 bit val ue */typedef signed long int int32; /* Signed 32 bit value */typedef signed short int16; /* Signed 16 bit value * /typedef signed char int8; /* Signed 8 bit value *///下面的不建议使用typedef unsigned char byte; /* Unsigned 8 bit valu e type. */typedef unsigned short word; /* Unsinged 16 bit va lue type. */typedef unsigned long dword; /* Unsigned 32 bit v alue type. */typedef unsigned char uint1; /* Unsigned 8 bit val ue type. */typedef unsigned short uint2; /* Unsigned 16 bit value type. */typedef unsigned long uint4; /* Unsigned 32 bit val ue type. */typedef signed char int1; /* Signed 8 bit value ty pe. */typedef signed short int2; /* Signed 16 bit value t ype. */typedef long int int4; /* Signed 32 bit value typ e. */typedef signed long sint31; /* Signed 32 bit value * /typedef signed short sint15; /* Signed 16 bit value*/typedef signed char sint7; /* Signed 8 bit value */3，得到指定地址上的一个字节或字#define MEM_B( x ) ( *( (byte *) (x) ) )#define MEM_W( x ) ( *( (word *) (x) ) )4，求最大值和最小值#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )5，得到一个field在结构体(struct)中的偏移量#define FPOS( type, field ) \/*lint -e545 */ ( (dword) &(( type *) 0)-> field ) /*lint +e54 5 */6,得到一个结构体中field所占用的字节数#define FSIZ( type, field ) sizeof( ((type *) 0)->field )7，按照LSB格式把两个字节转化为一个Word#define FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )8，按照LSB格式把一个Word转化为两个字节#define FLOPW( ray, val ) \(ray)[0] = ((val) / 256); \(ray)[1] = ((val) & 0xFF)9，得到一个变量的地址（word宽度）#define B_PTR( var ) ( (byte *) (void *) &(var) )#define W_PTR( var ) ( (word *) (void *) &(var) )10，得到一个字的高位和低位字节#define WORD_LO(xxx) ((byte) ((word)(xxx) & 255))#define WORD_HI(xxx) ((byte) ((word)(xxx) >> 8))11，返回一个比X大的最接近的8的倍数#define RND8( x ) ((((x) + 7) / 8 ) * 8 )12，将一个字母转换为大写#define UPCASE( c ) ( ((c) >= 'a' && (c) <= 'z') ? ((c) - 0x2 0) : (c) )13，判断字符是不是10进值的数字#define DECCHK( c ) ((c) >= '0' && (c) <= '9')14，判断字符是不是16进值的数字#define HEXCHK( c ) ( ((c) >= '0' && (c) <= '9') ||\((c) >= 'A' && (c) <= 'F') ||\((c) >= 'a' && (c) <= 'f') )15，防止溢出的一个方法#define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : ( val))16，返回数组元素的个数#define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )17，返回一个无符号数n尾的值MOD_BY_POWER_OF_TWO(X,n)=X%(2^n)#define MOD_BY_POWER_OF_TWO( val, mod_by ) \( (dword)(val) & (dword)((mod_by)-1) )18，对于IO空间映射在存储空间的结构，输入输出处理#define inp(port) (*((volatile byte *) (port)))#define inpw(port) (*((volatile word *) (port)))#define inpdw(port) (*((volatile dword *)(port)))#define outp(port, val) (*((volatile byte *) (port)) = ((byt e) (val)))#define outpw(port, val) (*((volatile word *) (port)) = ((w ord) (val)))#define outpdw(port, val) (*((volatile dword *) (port)) = ( (dword) (val)))[2005-9-9添加]19,使用一些宏跟踪调试A N S I标准说明了五个预定义的宏名。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1，防止一个头文件被重复包含#ifndef COMDEF_H#define COMDEF_H// 头文件内容#endif2，重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。
typedef unsigned char boolean; /* Boolean value type. */typedef unsigned long int uint32; /* Unsigned 32 bIT value */typedef unsigned short uint16; /* Unsigned 16 bit value */typedef unsigned char uint8; /* Unsigned 8 bit value */typedef signed long int int32; /* Signed 32 bit value */typedef signed short int16; /* Signed 16 bit value */typedef signed char int8; /* Signed 8 bit value *///下面的不建议使用typedef unsigned char byte; /* Unsigned 8 bit value type. */typedef unsigned short word; /* Unsinged 16 bit value type. */typedef unsigned long dword; /* Unsigned 32 bit value type. */typedef unsigned char uint1; /* Unsigned 8 bit value type. */typedef unsigned short uint2; /* Unsigned 16 bit value type. */typedef unsigned long uint4; /* Unsigned 32 bit value type. */typedef signed char int1; /* Signed 8 bit value type. */typedef signed short int2; /* Signed 16 bit value type. */typedef long int int4; /* Signed 32 bit value type. */typedef signed long sint31; /* Signed 32 bit value */typedef signed short sint15; /* Signed 16 bit value */typedef signed char sint7; /* Signed 8 bit value */3，得到指定地址上的一个字节或字#define MEM_B( x ) ( *( (byte *) (x) ) )#define MEM_W( x ) ( *( (word *) (x) ) )4，求最大值和最小值#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )#define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )5. 得到一个field在结构体(struct)中的偏移量#define FPOS( type, field ) \( (dword) &(( type *) 0)-> field )6. 得到一个结构体中field所占用的字节数#define FSIZ( type, field ) sizeof( ((type *) 0)->field )7，按照LSB格式把两个字节转化为一个Word#define FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )8，按照LSB格式把一个Word转化为两个字节#define FLOPW( ray, val ) \(ray)[0] = ((val) / 256); \(ray)[1] = ((val) & 0xFF)9，得到一个变量的地址（word宽度）#define B_PTR( var ) ( (byte *) (void *) &(var) )#define W_PTR( var ) ( (word *) (void *) &(var) )10，得到一个字的高位和低位字节#define WORD_LO(xxx) ((byte) ((word)(xxx) & 255))#define WORD_HI(xxx) ((byte) ((word)(xxx) >> 8))11，返回一个比X大的最接近的8的倍数#define RND8( x ) ((((x) + 7) / 8 ) * 8 )12，将一个字母转换为大写#define UPCASE( c ) ( ((c) >= 'a' && (c) <= 'z') ? ((c) - 0x20) : (c) )13，判断字符是不是10进值的数字#define DECCHK( c ) ((c) >= '0' && (c) <= '9')14，判断字符是不是16进值的数字#define HEXCHK( c ) ( ((c) >= '0' && (c) <= '9') ||((c) >= 'A' && (c) <= 'F') ||((c) >= 'a' && (c) <= 'f') )15，防止溢出的一个方法#define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))16，返回数组元素的个数#define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )17，返回一个无符号数n尾的值MOD_BY_POWER_OF_TWO(X,n)=X%(2^n) #define MOD_BY_POWER_OF_TWO( val, mod_by )( (dword)(val) & (dword)((mod_by)-1) )18，对于IO空间映射在存储空间的结构，输入输出处理#define inp(port) (*((volatile byte *) (port)))#define inpw(port) (*((volatile word *) (port)))#define inpdw(port) (*((volatile dword *)(port)))#define outp(port, val) (*((volatile byte *) (port)) = ((byte) (val)))#define outpw(port, val) (*((volatile word *) (port)) = ((word) (val)))#define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val)))19. 使用一些宏跟踪调试A N S I标准说明了五个预定义的宏名。
它们是：_ L I N E __ F I L E __ D A T E __ T I M E __ S T D C _如果编译不是标准的，则可能仅支持以上宏名中的几个，或根本不支持。
记住编译程序也许还提供其它预定义的宏名。
_ L I N E _及_ F I L E _宏指令在有关# l i n e的部分中已讨论，这里讨论其余的宏名。
_ D AT E _宏指令含有形式为月/日/年的串，表示源文件被翻译到代码时的日期。
源代码翻译到目标代码的时间作为串包含在_ T I M E _中。
串形式为时：分：秒。
如果实现是标准的，则宏_ S T D C _含有十进制常量1。
如果它含有任何其它数，则实现是非标准的。
可以定义宏，例如:当定义了_DEBUG，输出数据信息和所在文件所在行#ifdef _DEBUG#define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%d”,date,_LINE_,_FILE_)#else#define DEBUGMSG(msg,date)#endif20. 宏定义防止使用是错误用小括号包含。
例如：#define ADD(a,b) （a+b）用do{}while(0)语句包含多语句防止错误例如：#difne DO(a,b) a+b;a++;应用时：if(….)DO(a,b); //产生错误else解决方法: #difne DO(a,b) do{a+b;a++;}while(0)宏中"#"和"##"的用法一、一般用法我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起.用法:＃i nclude<cstdio>＃i nclude<climits>using namespace std;#define STR(s) #s#define CONS(a,b) int(a##e##b)int main(){printf(STR(vck)); // 输出字符串"vck"printf("%d\n", CONS(2,3)); // 2e3 输出:2000return 0;}二、当宏参数是另一个宏的时候需要注意的是凡宏定义里有用'#'或'##'的地方宏参数是不会再展开.1, 非'#'和'##'的情况#define TOW (2)#define MUL(a,b) (a*b)printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW));这行的宏会被展开为：printf("%d*%d=%d\n", (2), (2), ((2)*(2)));MUL里的参数TOW会被展开为(2).--------------------------------------------------------------------------------2, 当有'#'或'##'的时候#define A (2)#define STR(s) #s#define CONS(a,b) int(a##e##b)printf("int max: %s\n", STR(INT_MAX)); // INT_MAX ＃i nclude<climits>这行会被展开为：printf("int max: %s\n", "INT_MAX");printf("%s\n", CONS(A, A)); // compile error这一行则是：printf("%s\n", int(AeA));INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏.加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数.#define A (2)#define _STR(s) #s#define STR(s) _STR(s) // 转换宏#define _CONS(a,b) int(a##e##b)#define CONS(a,b) _CONS(a,b) // 转换宏printf("int max: %s\n", STR(INT_MAX)); // INT_MAX,int型的最大值，为一个变量＃i nclude<climits>输出为: int max: 0x7fffffffSTR(INT_MAX) --> _STR(0x7fffffff) 然后再转换成字符串；printf("%d\n", CONS(A, A));输出为：200CONS(A, A) --> _CONS((2), (2)) --> int((2)e(2))三、'#'和'##'的一些应用特例1、合并匿名变量名#define ___ANONYMOUS1(type, var, line) type var##line#define __ANONYMOUS0(type, line) ___ANONYMOUS1(type, _anonymous, line)#define ANONYMOUS(type) __ANONYMOUS0(type, __LINE__)例：ANONYMOUS(static int); 即: static int _anonymous70; 70表示该行行号；第一层：ANONYMOUS(static int); --> __ANONYMOUS0(static int, __LINE__);第二层： --> ___ANONYMOUS1(static int, _anonymous, 70);第三层：--> static int _anonymous70;即每次只能解开当前层的宏，所以__LINE__在第二层才能被解开；2、填充结构#define FILL(a) {a, #a}enum IDD{OPEN, CLOSE};typedef struct MSG{IDD id;const char * msg;}MSG;MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};相当于：MSG _msg[] = {{OPEN, "OPEN"},{CLOSE, "CLOSE"}};3、记录文件名#define _GET_FILE_NAME(f) #f#define GET_FILE_NAME(f) _GET_FILE_NAME(f)static char FILE_NAME[] = GET_FILE_NAME(__FILE__);4、得到一个数值类型所对应的字符串缓冲大小#define _TYPE_BUF_SIZE(type) sizeof #type#define TYPE_BUF_SIZE(type) _TYPE_BUF_SIZE(type)char buf[TYPE_BUF_SIZE(INT_MAX)];--> char buf[_TYPE_BUF_SIZE(0x7fffffff)];--> char buf[sizeof "0x7fffffff"];这里相当于：char buf[11];============================================================================ ============================================================================ ====C（和C++）中的宏（Macro）属于编译器预处理的范畴，属于编译期概念（而非运行期概念）。