宏定义的作用
宏定义是C提供的三种预处理功能的其中一种，这三种预处理包括：宏定义、文件包含、
条件编译
编辑本段1.不带参数的宏定义：
宏定义又称为宏代换、宏替换，简称“宏”。
格式：
#define 标识符字符串
其中的标识符就是所谓的符号常量，也称为“宏名”。
预处理（预编译）工作也叫做宏展开：将宏名替换为字符串。
掌握"宏"概念的关键是“换”。一切以换为前提、做任何事情之前先要换，准确理解之前就要
“换”。
即在对相关命令或语句的含义和功能作具体分析之前就要换：
例：
#define PI 3.1415926
把程序中出现的PI全部换成3.1415926
说明：
（1）宏名一般用大写
（2）使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。例
如：数组大小常用宏定义
（3）预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法
检查。
（4）宏定义末尾不加分号；
（5）宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。
（6）可以用#undef命令终止宏定义的作用域
（7）宏定义可以嵌套
（8）字符串" "中永远不包含宏
（9）宏定义不分配内存，变量定义分配内存。
编辑本段2.带参数的宏定义：
除了一般的字符串替换，还要做参数代换
格式：
#define 宏名（参数表）字符串
例如：#define S(a,b) a*b
area=S(3,2)；第一步被换为area=a*b; ，第二步被换为area=3*2;
类似于函数调用，有一个哑实结合的过程：
（1）实参如果是表达式容易出问题
#define S(r) r*r
area=S(a+b);第一步换为area=r*r;,第二步被换为area=a+b*a+b;
正确的宏定义是#define S(r) ((r)*(r))
（2）宏名和参数的括号间不能有空格
（3）宏替换只作替换，不做计算，不做表达式求解
（4）函数调用在编译后程序运行时进行，并且分配内存。宏替换在编译前进行，不分配内
存
（5）宏的哑实结合不存在类型，也没有类型转换。
（6）函数只有一个返回值，利用宏则可以设法得到多个值
（7）宏展开使源程序变长，函数调用不会
（8）宏展开不占运行时间，只占编译时间，函数调用占运行时间（分配内存、保留现场、
值传递、返回值
C语言宏定义技巧（常用宏定义）
写好C语言，漂亮的宏定义很重要，使用宏定义可以防止出错，提高可移植性，可读性，
方便性等等。
下面列举一些成熟软件中常用得宏定义:
1，防止一个头文件被重复包含
#ifndef COMDEF_H
#define COMDEF_H
//头文件内容
#endif
2，重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方
便移植。
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 longint int32; /* Signed 32 bit value */
typedef signed short int16; /* Signed 16 bit value */
typedef signed char int8; /* 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)))
[2005-9-9添加]
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)
#endif
20，宏定义防止使用是错误
用小括号包含。
例如：#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)
宏中"#"和"##"的用法
一、一般用法
我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起.
用法:
#include
#include
using namespace std;
#define STR(s) #s
#define CONS(a,b) int(a##e##b)
int main()
{
printf(STR(vck)); // 输出字符串"vck"
printf("%d
", CONS(2,3)); // 2e3 输出:2000
return 0;
}
第十五讲宏定义、文件包含和条件编译 ?C语言提供的预处理功能主要有三种： 宏定义 文件包含 条件编译 ?为了区别预处理命令和C语句、定义和说明语句，规定： 预处理命令行必须在一行的开头； 必须以#开始； 每行末尾不能加分号。 1、宏定义 宏定义 1．1不带参数的宏定义 不带参数的宏定义命令形式为： #define 宏名字符串 或#define 宏名 #define的作用是用指定的标识符（宏名）来代表字符串。其中#define是宏定义命令，宏名是一个标识符。 【例】输入一个圆的半径，计算并输出圆的面积和周长 #define PI 3.14159 main( ) {float l,s,r; /*l：周长，s：面积，r：半径*/ printf("Please input radius: "); scanf("%f",&r); /*输入半径*/ l=2.0*r*PI; /*计算周长*/ s=PI*r*r; /*计算面积*/ printf("l=%10.4f\ns=%10.4f\n",l,s); } 说明： 为了与变量名区别，建议宏名一般用大写字母。使用宏名代替一个 字符串，目的一是减少程序中某些重复使用字符串的书写量，其二 是增加程序的可读性。在编译预处理过程中会进行宏展开。 当宏定义在一行中写不下，需要在下一行继续时，只需在最后一个 字符后紧接一个反斜线“\”。注意在第二行开始不要有空格，否则空 格会一起被替换。 例如：#define LEAP_YEAR year % 4==0\ && year %100!=0 || year % 400==0 在C语言中，宏定义一般写在程序开头。宏名的有效范围为定义命 令之后到本源文件结束，除非用#undef命令终止宏名的作用域。 对程序中用双引号括起来的字符串内的子串和用户标识符中的成分 不做替换。例如已定义： 同一个宏名不能重复定义，除非两个宏定义命令行完全一致。 1．2带参数的宏定义 形参表中的不同形参之间用逗号隔开，字符串中包含形参表中的参数，带参
宏定义的作用 宏定义是C提供的三种预处理功能的其中一种，这三种预处理包括：宏定义、文件包含、 条件编译 编辑本段1.不带参数的宏定义： 宏定义又称为宏代换、宏替换，简称“宏”。 格式： #define 标识符字符串 其中的标识符就是所谓的符号常量，也称为“宏名”。 预处理（预编译）工作也叫做宏展开：将宏名替换为字符串。 掌握"宏"概念的关键是“换”。一切以换为前提、做任何事情之前先要换，准确理解之前就要 “换”。 即在对相关命令或语句的含义和功能作具体分析之前就要换： 例： #define PI 3.1415926 把程序中出现的PI全部换成3.1415926 说明： （1）宏名一般用大写 （2）使用宏可提高程序的通用性和易读性，减少不一致性，减少输入错误和便于修改。例 如：数组大小常用宏定义 （3）预处理是在编译之前的处理，而编译工作的任务之一就是语法检查，预处理不做语法 检查。 （4）宏定义末尾不加分号； （5）宏定义写在函数的花括号外边，作用域为其后的程序，通常在文件的最开头。 （6）可以用#undef命令终止宏定义的作用域 （7）宏定义可以嵌套 （8）字符串" "中永远不包含宏 （9）宏定义不分配内存，变量定义分配内存。 编辑本段2.带参数的宏定义： 除了一般的字符串替换，还要做参数代换 格式： #define 宏名（参数表）字符串 例如：#define S(a,b) a*b area=S(3,2)；第一步被换为area=a*b; ，第二步被换为area=3*2; 类似于函数调用，有一个哑实结合的过程： （1）实参如果是表达式容易出问题 #define S(r) r*r area=S(a+b);第一步换为area=r*r;,第二步被换为area=a+b*a+b; 正确的宏定义是#define S(r) ((r)*(r)) （2）宏名和参数的括号间不能有空格 （3）宏替换只作替换，不做计算，不做表达式求解 （4）函数调用在编译后程序运行时进行，并且分配内存。宏替换在编译前进行，不分配内 存 （5）宏的哑实结合不存在类型，也没有类型转换。
d efine宏定义中的#，##，@#及\符号(ZT) C++ STL学习2011-04-24 18:04:03 阅读19 评论0 字号：大中小订阅 1、# （stringizing）字符串化操作符。其作用是：将宏定义中的传入参数名转换成用一对双引号括起来参数名字符串。其只能用于有传入参数的宏定义中，且必须置于宏定义体中的参数名前。 如： #define example(instr) printf("the input string is:\t%s\n",#instr) #define example1(instr) #instr 当使用该宏定义时： example(abc)；在编译时将会展开成：printf("the input string is:\t%s\n","abc"); string str=example1(abc)；将会展成：string str="abc"； 注意： 对空格的处理 a。忽略传入参数名前面和后面的空格。 如：str=example1( abc )；将会被扩展成str="abc"； b.当传入参数名间存在空格时，编译器将会自动连接各个子字符串，用每个子字符串中只以一个空格连接，忽略其中多余一个的空格。
如：str=exapme( abc def); 将会被扩展成str="abc def"； 2、## （token-pasting）符号连接操作符 宏定义中：参数名，即为形参，如#define sum(a,b) (a+b)；中a和b 均为某一参数的代表符号，即形式参数。 而##的作用则是将宏定义的多个形参成一个实际参数名。 如： #define exampleNum(n) num##n int num9=9; 使用： int num=exampleNum(9); 将会扩展成int num=num9; 注意： 1.当用##连接形参时，##前后的空格可有可无。 如：#define exampleNum(n) num ## n 相当于#define exampleNum(n) num##n 2.连接后的实际参数名，必须为实际存在的参数名或是编译器已知的宏定义 // preprocessor_token_pasting.cpp
宏定义中##和＃的作用
————————————————————————————————作者: ————————————————————————————————日期： ?
内核中有很多的宏定义，在宏定义ｄefｉｎe中经常看到两个字符串##和#,这里把它的用法做一下说明： ##是一个连接符号,用于把参数连在一起 例如: >＃ｄefine FOO（ａrg) my##arg 则 > FOO(abｃ) 相当于myaｂｃ #是“字符串化”的意思。出现在宏定义中的#是把跟在后面的参数转换成一个字符串例如: > #dｅfineＳTRCPＹ(dst,src）ｓtrcpｙ(dst,#ｓrc) 则 >STRＣＰY（bufｆ, abｃ） 相当于sｔrcpｙ(bｕｆf, "abc"） 另外,如果##后的参数本身也是一个宏的话,#＃会阻止这个宏的展开。 #deｆine STRCPY（a, b）ｓtrｃpy(a##＿p, #b) int ｍain() { char var1_ｐ［２０]； cｈaｒvａｒ２_p[３0]； ｓｔrcpy(ｖar1＿ｐ，＂aaaａ")； sｔrcpy(var2_ｐ, ＂ｂbbb")； STRCPＹ(ｖar1，var２); STRCPＹ(ｖａｒ２, ｖａr1）; pｒintf（＂ｖaｒ１= %s\n", var1_p）; printｆ(＂var2= %s＼n", var２＿p); ｒｅｔurn 0; ／＊注意这里＊／ STRＣPY(STRＣPY(vaｒ1,vaｒ２）,vaｒ２); ／＊这里是否会展开为：ｓtrcｐｙ（strｃｐy(vaｒ1_p,"vａｒ2")_ｐ,"ｖaｒ２“）？ * 答案是否定的: * 展开结果将是：strcpy(STＲCPＹ(var1,var2）_p,＂var2") *## 阻止了参数的宏展开! *如果宏定义里没有用到#和＃#, 宏将会完全展开 ＊/ } ／//////////／／／//／//／/／／//／／///／／／////／//////／//／/////／/／／/／/／/／/／///／///／
C语言宏定义中"#"，"#@"和"##"的用法一、引言 #define macro(a)#a #define macro2(a,b)a##b #define macro3(a,b,c)a##b##c #a,表示a不再是一个变量,而变成了字符串"a" ##表示连接,a##b,表示输入的参数名为ab,a##b##c同理,代表变量名为:abc 测试例子: int x=3; int y=4; int xy=10; int xyz=20; CString str; OutputDebugString(macro(x)); str.Format("%d",macro2(x,y)); OutputDebugString(str); str.Format("%d",macro3(x,y,z)); OutputDebugString(str); 输出结果为: x 10 20 第一个为x,marco(x),x变成了"x"字符串 第二个为10,macro(x,y),就是变量xy 第三个为20,macro(x,y,z),就是变量xyz 二、一般用法 #把宏参数变为一个字符串，#@把宏参数变为一个字符，##把两个宏参数贴合在一起。
#include
KINBAS宏定义鼠标设置说明书（通用版） 1．找到安装文件，双击此图示开始安装，按照提示一步步操作即可。下载地址在宝贝详情页，或找客服索取链接 2．鼠标支持LOL编程软件游戏宏，无需繁琐操作，一键设置（光速QA、酒桶E闪,盲僧R闪、盲僧4眼W瞬、盲僧2眼W瞬、猴子EAQ、皓月QR皇子二连、牛头二连，需要注意的是逆战和CF 这两个游戏屏蔽宏定义功能，在这两款游戏中可能暂时无法使用宏定义功能 一、基本设置：本自定义程序分三部分：基本设置；高级设置；呼吸灯设置 以设置5号键(看下图)宏功能为例，按下图大的蓝色数字123依次点击） 再点击大的蓝色数字4旁的“应用”按钮后，盲僧R闪功能设置成功 2.其它宏功能也是这样来按上面蓝色数字1 2 3步设置后，点第4步左边的应用两
个字，就设置成功了， 3.如果设置后按键功能需要恢复，点一下程序下面的“出厂设置”就可以恢复默认按 键功能了，或者退出我们的应该程序后，按键功能恢复默认 二．高级设置：录制自己需要的宏，这里的操作相对复杂一些（请根据步骤操作，用多几天，用熟悉了，设置也就不难了） 根据下图：运行软件，见下图数字数字操作指引：1点高级设置2在宏名称项中输入"测试宏"3点新增按钮,4.点录制,5，此时按下键盘你需要的操作（比如连续按下DDD),6此时第4步的录制变成了停止按钮，请点停止,7点保存按钮，录制完成 8点基本设置按此说明书的第1页基本设置使用方法里，选择自己刚才录制好的“测试宏”即可，请注意,(如果录制宏后没点停止,键盘此时在系统的操作是没反应的) 备注： 三．宏定义最多可设置12项，如超出，可删除平常少用快捷功能，再添加！另外，根据网速不同，可能有些宏需要调整，功能才得以实现。 四．呼吸灯设置：
1.函数调用时，先求出实参表达式的值，然后带入形参。而使用带参的宏只是进行简单的字符替换。 2.函数调用是在程序运行时处理的，分配临时的内存单元；而宏展开则是在编译时进行的，在展开时并不分配内存单元，不进行值的传递处理，也没有“返回值”的概念。 3.对函数中的实参和形参都要定义类型，二者的类型要求一致，如不一致，应进行类型转换；而宏不存在类型问题，宏名无类型，它的参数也无类型，只是一个符号代表，展开时带入指定的字符即可。宏定义时，字符串可以是任何类型的数据。 4.调用函数只可得到一个返回值，而用宏可以设法得到几个结果。 5.使用宏次数多时，宏展开后源程序长，因为每展开一次都使程序增长，而函数调用不使源程序变长。 6.宏替换不占运行时间，只占编译时间；而函数调用则占运行时间（分配单元、保留现场、值传递、返回）。 一般来说，用宏来代表简短的表达式比较合适。 内联函数和宏很类似，而区别在于，宏是由预处理器对宏进行替代，而内联函数是通过编译器控制来实现的。而且内联函数是真正的函数，只是在需要用到的时候，内联函数像宏一样的展开，所以取消了函数的参数压栈，减少了调用的开销。你可以象调用函数一样来调用内联函数，而不必担心会产生于处理宏的一些问题。 当然，内联函数也有一定的局限性。就是函数中的执行代码不能太多了，如果，内联函数的函数体过大，一般的编译器会放弃内联方式，而采用普通的方式调用函数。这样，内联函数就和普通函数执行效率一样了。内联函数是不能为虚函数的，但样子上写成了内联的，即隐含的内联方式。在某种情况下，虽然有些函数我们声明为了所谓“内联”方式，但有时系统也会把它当作普通的函数来处理，这里的虚函数也一样，虽然同样被声明为了所谓“内联”方式,但系统会把它当然非内联的方式来处理。
假设a.h内容如下： #ifndef AH #define AH typedef int INT; #endif b.h内容如下： #include "a.h" a.c内容如下： #include "a.h" #include "b.h" main() { INT a; } (1)如果a.h中不写#ifndef #define ... #endif的话 a.c展开结果会是下面这样： typedef int INT; typedef int INT; main() { INT a; } 编译结果会报标识符INT重复错误。 (2)如果a.h中加上#ifndef #define ... #endif的话 a.c展开结果会是下面这样： #ifndef AH #define AH
typedef int INT; #endif #ifndef AH #define AH typedef int INT; #endif main() { INT a; } 这样的话，因为程序中已经定义了一次AH，所以不会走到第二次声明INT的分支。所以不会出错。 #ifndef #define #endif的用法整理：shichenghua https://www.doczj.com/doc/0a12568414.html,/blog/?56085/action_viewspace_itemid_1145.htm l (前段时间要到这个，感觉shichenghua整理得不错，所以收藏到此处，若不同意，随时可以撤下 谢谢shichenghua） 文件中的#ifndef
头件的中的#ifndef，这是一个很关键的东西。比如你有两个C文件，这两个C文件都include了同一个头文件。而编译时，这两个C文件要一同编译成一个可运行文件，于是问题来了，大量的声明冲突。 还是把头文件的内容都放在#ifndef和#endif中吧。不管你的头文件会不会被多个文件引用，你都要加上这个。一般格式是这样的： #ifndef <标识> #define <标识> ...... ...... #endif <标识>在理论上来说可以是自由命名的，但每个头文件的这个“标识”都应该是唯一的。标识的命名规则一般是头文件名全大写，前后加下划线，并把文件名中的“.”也变成下划线，如：stdio.h #ifndef _STDIO_H_ #define _STDIO_H_ ...... #endif 2.在#ifndef中定义变量出现的问题（一般不定义在#ifndef中）。 #ifndef AAA #define AAA ... int i; ... #endif 里面有一个变量定义 在vc中链接时就出现了i重复定义的错误，而在c中成功编译。 结论：
在介绍学习VBA之前，应该花几分钟录制一个宏。 新术语：“宏”，指一系列EXCEL能够执行的VBA语句。 以下将要录制的宏非常简单，只是改变单元格颜色。请完成如下步骤： 1)打开新工作簿，确认其他工作簿已经关闭。 2)选择A1单元格。调出“常用”工具栏。 3)选择“工具”—“宏”—“录制新宏”。 4)输入“改变颜色”作为宏名替换默认宏名，单击确定,注意，此时状态栏中显示“录制”，特别是“停止录制”工具栏也显示出来。替换默认宏名主要是便于分别这些宏。★宏名最多可为255个字符，并且必须以字母开始。其中可用的字符包括：字母、数字和下划线。宏名中不允许出现空格。通常用下划线代表空格。 5)选择“格式”的“单元格”，选择“图案”选项中的红色,单击“确定”。 6)单击“停止录制”工具栏按钮，结束宏录制过程。 ※如果“停止录制”工具栏开始并未出现，请选择“工具”—“宏”—“停止录制”。 录制完一个宏后就可以执行它了。 1.4 执行宏 当执行一个宏时，EXCEL按照宏语句执行的情况就像VBA代码在对EXCEL进行“遥控”。但VBA的“遥控”不仅能使操作变得简便，还能使你获得一些使用EXCEL标准命令所无法实现的功能。而且，一旦熟悉了EXCEL的“遥控”，你都会奇怪自己在没有这些“遥控”的情况下，到底是怎么熬过来的。要执行刚才录制的宏，可以按以下步骤进行： 1）选择任何一个单元格，比如A3。 2）选择“工具”—“宏”—“宏”，显示“宏”对话框。 3）选择“改变颜色”，选择“执行”，则A3单元格的颜色变为红色。试着选择其它单元格和几个单元格组成的区域，然后再执行宏，以便加深印象。 1.5 查看录制的代码 到底是什么在控制EXCEL的运行呢?你可能有些疑惑.好,让我们看看VBA的语句吧. 1）选择“工具”—“宏”—“宏”，显示“宏”对话框。 2）单击列表中的“改变颜色”,选择“编辑”按钮。 此时，会打开VBA的编辑器窗口（VBE）。关于该编辑器，以后再详细说明，先将注意力集中到显示的代码上。代码如下：（日期和姓名会有不同） Sub 改变颜色() ' ' 改变颜色Macro ' xw 记录的宏2000-6-10 '
一、#define的基本用法 #define是C语言中提供的宏定义命令，其主要目的是为程序员在编程时提供一定的方便，并能在一定程度上提高程序的运行效率，但学生在学习时往往不能理解该命令的本质，总是在此处产生一些困惑，在编程时误用该命令，使得程序的运行与预期的目的不一致，或者在读别人写的程序时，把运行结果理解错误，这对 C语言的学习很不利。 1 #define命令剖析 1.1 #define的概念 #define命令是C语言中的一个宏定义命令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。 该命令有两种格式：一种是简单的宏定义，另一种是带参数的宏定义。 (1)简单的宏定义： #define<宏名><字符串> 例：#define PI 3.1415926 (2) 带参数的宏定义 #define<宏名>(<参数表>)<宏体> 例：#define A(x) x 一个标识符被宏定义后，该标识符便是一个宏名。这时，在程序中出现的是宏名，在该程序被编译前，先将宏名用被定义的字符串替换，这称为宏替换，替换后才进行编译，宏替换是简单的替换。 1.2 宏替换发生的时机 为了能够真正理解#define的作用，让我们来了解一下对C语言源程序的处理过程。当我们在一个集成的开发环境如Turbo C中将编写好的源程序进行编译时，实际经过了预处理、编译、汇编和连接几个过程。其中预处理器产生编译器的输出，它实现以下的功能： （1）文件包含 可以把源程序中的#include 扩展为文件正文，即把包含的.h文件找到并展开到#include 所在处。 （2）条件编译 预处理器根据#if和#ifdef等编译命令及其后的条件，将源程序中的某部分包含进来或排除在外，通常把排除在外的语句转换成空行。 （3）宏展开 预处理器将源程序文件中出现的对宏的引用展开成相应的宏定义，即本文所说的#define的功能，由预处理器来完成。
c语言中的#号的作用 宏中"#"和"##"的用法 一、一般用法 我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起. 用法: ＃i nclude
二、当宏参数是另一个宏的时候 需要注意的是凡宏定义里有用'#'或'##'的地方宏参数是不会再展开. 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
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型的最
内核中有很多的宏定义，在宏定义define中经常看到两个字符串##和#，这里把它的用法做一下说明： ##是一个连接符号，用于把参数连在一起 例如： > #define FOO(arg) my##arg 则 > FOO(abc) 相当于myabc #是“字符串化”的意思。出现在宏定义中的#是把跟在后面的参数转换成一个字符串例如： > #define STRCPY(dst, src) strcpy(dst, #src) 则 > STRCPY(buff, abc) 相当于strcpy(buff, "abc") 另外，如果##后的参数本身也是一个宏的话，##会阻止这个宏的展开。 #define STRCPY(a, b) strcpy(a ## _p, #b) int main() { char var1_p[20]; char var2_p[30]; strcpy(var1_p, "aaaa"); strcpy(var2_p, "bbbb"); STRCPY(var1, var2); STRCPY(var2, var1); printf("var1 = %s\n", var1_p); printf("var2 = %s\n", var2_p); return 0; /* 注意这里*/ STRCPY(STRCPY(var1,var2),var2); /* 这里是否会展开为：strcpy(strcpy(var1_p,"var2")_p,"var2“）？ * 答案是否定的： * 展开结果将是：strcpy(STRCPY(var1,var2)_p,"var2") * ## 阻止了参数的宏展开! * 如果宏定义里没有用到# 和##, 宏将会完全展开 */ } ///////////////////////////////////////////////////////////////////////// tell you about ## in common text
宏定义有无参数宏定义和带参数宏定义两种。 无参数的宏定义的一般形式为 # define 标识符字符序列 其中# define之后的标识符称为宏定义名(简称宏名)，要求宏名与字符序列之间用空格符分隔。这种宏定义要求编译预处理程序将源程序中随后所有的定名的出现(注释与字符串常量中的除外)均用字符序列替换之。前面经常使用的定义符号常量是宏定义的最简单应用。如有：# define TRUE 1 # define FALSE 0 则在定义它们的源程序文件中，凡定义之后出现的单词TRUE将用1替代之；出现单词FALSE 将用0替代之。 在宏定义的＃之前可以有若干个空格、制表符，但不允许有其它字符。宏定义在源程序中单独另起一行，换行符是宏定义的结束标志。如果一个宏定义太长，一行不够时，可采用续行的方法。续行是在键人回车符之前先键入符号"\"。注意回车要紧接在符号"\"之后，中间不能插入其它符号。 宏定义的有效范围称为宏定义名的辖域，辖域从宏定义的定义结束处开始到其所在的源程序文件末尾。宏定义名的辖域不受分程序结构的影响。可以用预处理命令#undef终止宏定义名的辖域。 在新的宏定义中，可以使用前面已定义的宏名。例如， # define R 2.5 # define PI 3.1415926 # define Circle 2*PI*R # define Area PI* R * R 程序中的Circle被展开为2*3.1415926* 2.5，Area被展开为3.1415926*2.5*2.5。 如有必要，宏名可被重复定义。被重复定义后，宏名原先的意义被新意义所代替。 通常，无参数的宏定义多用于定义常量。程序中统一用宏名表示常量值，便于程序前后统一，不易出错，也便于修改，能提高程序的可读性和可移植性。特别是给数组元素个数一个宏定义，并用宏名定义数组元素个数能部分弥补数组元素个数固定的不足。 注意：预处理程序在处理宏定义时，只作字符序列的替换工作，不作任何语法的检查。如果宏定义不当，错误要到预处理之后的编译阶段才能发现。宏定义以换行结束，不需要分号等符号作分隔符。如有以下定定义： # define PI 3.1415926； 原希望用PI求圆的周长的语句 c＝2*PI*r； 经宏展开后，变成 c＝2*3.1415926*r； 这就不能达到希望的要求。 带参数宏定义进一步扩充了无参数宏定义的能力，在字符序列替换同时还能进行参数替
c/c++宏的使用总结 在这里总结宏的使用方法欢迎补充 1 条件include 如下 CODE #ifndef MAIN_H_ #define MAIN_H_ 其它内容 #endif 上面在看到头文件时会看到作用就是阻止这个头文件被多次include 多次include就会出现重复的定义情况所以需要在每个头文件中都使用这个定义 如果还不是很了解要怎样使用可以看看 c的标准头文件如fcntl.h 2 条件编译 如下 CODE #ifdef _DEBUG printf("this debug info\n"); #endif 如果没有定义_DEBUG宏的话那么上面那一行是不会编译进去的 但是定义了_DEBUG后上面那行就会编译进去可以写个简单的程序测试 CODE #include
如一个软件的多语言版本等 如下 CODE #include
https://www.doczj.com/doc/0a12568414.html,/24994073_d.html C语言中的宏定义 14.3 宏定义 我们从第2章以来使用的宏被称为简单的宏，它们没有参数。预编译器也支持带参数的宏。本节会先讨论简单的宏，然后再讨论带参数的宏。在分别讨论它们之后，我们会研究一下二者共同的特性。 14.3.1 简单的宏 简单的宏定义有如下格式： [#define指令（简单的宏）] #define 标识符替换列表 替换列表是一系列的C语言记号，包括标识符、关键字、数、字符常量、字符串字面量、运算符和标点符号。当预处理器遇到一个宏定义时，会做一个“标识符”代表“替换列表”的记录。在文件后面的内容中，不管标识符在任何位置出现，预处理器都会用替换列表代替它。 不要在宏定义中放置任何额外的符号，否则它们会被作为替换列表的一部分。一种常见的错误是在宏定义中使用 = ： #define N = 100 /*** WRONG ***/ int a[N]; /* 会成为 int a[= 100]; */ 在上面的例子中，我们（错误地）把N定义成一对记号（= 和100）。 在宏定义的末尾使用分号结尾是另一个常见错误： #define N 100; /*** WRONG ***/ int a[N]; /* become int a[100;]; */ 这里N被定义为100和;两个记号。 在一个宏定义中，编译器可以检测到绝大多数由多余符号所导致的错误。但不幸的是，编译器会将每一处使用这个宏的地方标为错误， 而不会直接找到错误的根源——宏定义本身，因为宏定义已经被预处
理器删除了。 简单的宏主要用来定义那些被Kernighan和Ritchie称为“明示常量”（manifest constant）的东西。使用宏，我们可以给数值、字符和字符串命名。 #define STE_LEN 80 #define TRUE 1 #define FALSE 0 #define PI 3.14159 #define CR '\r' #define EOS '\0' 使用#define来为常量命名有许多显著的优点： l 程序会更易读。一个认真选择的名字可以帮助读者理解常量的意义。否则，程序将包含大量的“魔法数”，使读者难以理解。 l 程序会更易于修改。我们仅需要改变一个宏定义，就可以改变整个程序中出现的所有该常量的值。“硬编码的”常量会更难于修改，特别是有时候当他们以稍微不同的形式出现时。（例如，如果一个程序包含一个长度为100的数组，它可能会包含一个从0到99的循环。如果我们只是试图找到所有程序中出现的100，那么就会漏掉99。） l 可以帮助避免前后不一致或键盘输入错误。假如数值常量3.14159在程序中大量出现，它可能会被意外地写成3.1416或3.14195。 虽然简单的宏常用于定义常量名，但是它们还有其他应用。 l 可以对C语法做小的修改。实际上，我们可以通过定义宏的方式给C语言符号添加别名，从而改变C语言的语法。例如，对于习惯使用Pascal的begin和end （而不是C语言的{和}）的程序员，可以定义下面的宏： #define BEGIN { #define END } 我们甚至可以发明自己的语言。例如，我们可以创建一个LOOP“语句”，来实现一个无限循环： #define LOOP for (;;) 当然，改变C语言的语法通常不是个好主意，因为它会使程序很难被其他程序员所理解。 l 对类型重命名。在5.2节中，我们通过重命名int创建了一个Boolean类型：#define BOOL int
第九章编译预处理与带参数的主函数 一、单项选择题 1.C程序中，以#号带头的行是预编译（A）。 A.命令 B.语句 C.函数 D.字符串 2.下列正确的预编译命令是（B）。 A.define PI 3.14159 B.#define p(a,b) strcpy(a,b) C. #include stdio.h D. # define PI3.14159 3.下列命令或语句中，正确的是（C）。 A.#define MYNAME= “ABC” B.#include stdio.h C. for(i=0;i<10;i++); D.struct int stu{int name}; 4.下列命令或语句中，正确的是（A）。 A.#define PI 3.14159 B. include “stdio.h” C.for(i=0,i<10,i++)a++ D.static struct {int i;}b={2}; 5.下列命令或语句中，错误的是（B）。 A. #define PI 3.14159 B.#include
C/C++中的宏 宏的单行定义 #define A(x) T_##x #define B（x) #@x #define C（x) #x 我们假设：x=1，则有： A(1)------〉T_1 B(1)------〉'1' C(1)------〉"1" define可以替代多行的代码，例如MFC中的宏定义（非常的经典，虽然让人看了恶心） #define MACRO(arg1, arg2) do { \ /* declarations */ \ stmt1; \ stmt2; \ /* ... */ \ } while(0) /* (no trailing ; ) */ 关键是要在每一个换行的时候加上一个"\" MFC中常用宏及其作用如下: RUNTIME_CLASS获得运行时类的CRuntimeClass结构指针RUNTIME_CLASS( class_name ) DECLARE_DYNAMIC提供基本的运行时类型识别(声明) DECLARE_DYNAMIC( class_name ) IMPLEMENT_DYNAMIC提供基本的运行时类型识别(实现) IMPLEMENT_DYNAMIC (class_name, base_class_name ) DECLARE_DYNCREATE动态创建(声明) DECLARE_DYNCREA TE( class_name ) IMPLEMENT_DYNCREATE动态创建(实现) IMPLEMENT_DYNCREATE( class_name,base_class_name ) DECLARE_SERIAL对象序列化(声明) DECLARE_SERIAL( class_name ) IMPLEMENT_SERIAL对象序列化(实现)IMPLEMENT_SERIAL(class_name,base_class_name,wSchema) DECLARE_MESSAGE_MAP声明消息映射表DECLARE_MESSAGE_MAP() BEGIN_MESSAGE_MAP开始建立消息映射表BEGIN_MESSAGE_MAP( theClass, baseClass ) END_MESSAGE_MAP结构建立消息映射表END_MESSAGE_MAP() ON_COMMAND命令消息映射宏 ON_MESSAGE自定义消息映射宏 ON_WM_...MFC预定义消息映射宏 ON_BN_...,ON_EN_..控件通知消息映射宏 部分宏说明: a.RUNTIME_CLASS宏使程序能实时创建类的实例。为了让这个宏起作用，定义的类必须从CObject类派生而来，并且在派生类的定义中必须使用宏
C语言#define用法总结 黄海涛，2012-3-3 如果你还在为使用#define而迷茫，那请阅读这篇文章； 如果读完之后你还在迷茫，那请哪天心情好了，再回来读一遍。:) 欢迎跟着我的思路走…… 一、概述 1、宏定义 在C语言中，以#开头的为预处理命令。 定义形式： 2、本质 其本质是：使用宏定义中的字符串替换(Substitution)宏名。 这只是一种简单的代换，预处理程序对它不作任何检查。如有错误，只能在编译已 被宏展开后的源程序时发现。 3、替换时机 预处理是指在进行编译的第一遍扫描(词法扫描和语法分析)之前所作的工作。由预 处理程序负责完成。在源程序被编译之前，宏替换已经完成，其流程如下：源程序→预处理程序→预处理后的源程序→编译器 4、作用域 其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用# undef命令。 5、优缺点 ▲优点：宏定义使用得当，可以防止出错，提高可移植性，可读性等等；减少函数 调用的开销。 ▲缺点：可能存在参数副作用；展开后可能比函数调用开销更大。 ※规则一：保证在宏替换之后不会发生错误。 二、无参宏定义 1、定义的一般形式 #define identifier token-sequence #define 标识符字符串 2、简单常量 ●约束1：宏名通常采用易读大写字母表示。 ●约束2：宏定义不是说明或语句，在行末不必加分号，如加上分号则连分 号也一起替换。 ●约束3：宏名在源程序中若用引号引起来，则预处理程序不对其作宏替换。 如：
3、字符串为表达式 ※规则二：无参宏定义中字符串为表达式(即含有运算符)，必须加小括号()。 可见，有括号与无括号差别很大，请小心加括号，保证展开后是你所期望的。参考规则一。 4、 5、 6
01: 防止一个头文件被重复包含 #ifndef COMDEF_H #define COMDEF_H //头文件内容 #endif 02: 重新定义一些类型 防止由于各种平台和编译器的不同,而产生的类型字节数差异,方便移植。 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 */ 03: 得到指定地址上的一个字节或字 #define MEM_B(x) (*((byte *)(x))) #define MEM_W(x) (*((word *)(x))) 04: 求最大值和最小值 #define MAX(x,y) (((x)>(y)) ? (x) : (y)) #define MIN(x,y) (((x) < (y)) ? (x) : (y)) 05: 得到一个field在结构体(struct)中的偏移量 #define FPOS(type,field) ((dword)&((type *)0)->field) 06: 得到一个结构体中field所占用的字节数