㈠ c语言使用宏3个步骤是什么
c语言使用宏3个步骤是：
1）写出这个宏的定义，比如
#define ADD(a,b) ((a)+(b))
2）在代码中应用这个宏，例如
xx=ADD(3+4,5)*ADD(0,7)
3）预编译时系统自动展开宏，例如上述宏展开后的结果是
xx=((3+4)+(5))*((0)+(7))
㈡ c语言宏定义如何用用宏定义有什么优点
用#define 来定义，如#define Max 100
优点：在以后的程序中 要修改Max的大小 不用跑到程序中找 直接修改
#define Max 的大小即可。很方便。
㈢ c语言宏定义函数如何调用（里面含参数可以当函数用吗）
直接调用即可。如下示例：
#include<stdio.h>#definesum(b,c){intd=0;d=b+c;printf("两滑闹者的和:%d ",d);}intmain(){intx=0,y=0;scanf("%d%d",&x,&y);sum(x,y);return0;}
若是普通函数，则通过递归，可取的最大值，时间复杂度为O（n）。但若是宏函数，则宏展开为( a[n]>max(n-1)?a[n]:max(n-1) )，其中max(n-1)被调用了两遍，这样依此递归下去，时间复杂度会很高。
㈣ C语言 宏的使用
目测宏定义的3.14后面多了个分号。
㈤ 关于c语言宏定义这里是怎么用的
那个是分号，不是冒号。这个分号的作用就是函数调用语句末尾的分号
例如LED_BLUE宏展开后为digitalHi(LED1_GPIO_PORT,LED1_GPIO_PIN);digitalHi(LED2_GPIO_PORT,LED2_GPIO_PIN);digitalLo(LED3_GPIO_PORT,LED3_GPIO_PIN)
你只需要使用“LED_BLUE;”语句就可以关闭LED1和2，打开LED3。
宏定义可以执行多哪举李条函李迟数，宏定义的本质实际上答耐是文本替换，把宏定义的内容原原本本地替换到宏使用的地方。
另外，LED2_OFF后面似乎也应该有个分号，否则编译应该会出错的。除非LED2_OFF宏定义里加了分号。
㈥ C语言的宏(macro)是什么怎样使用宏
#define VERSION—STAMP "1．02" 上例中所定义的这种形式的宏通常被称为标识符。在上例中，标识符VERSION_STAMP即代表字符串"1．02"——在编译预处理时，源代码中的每个VERSION_STAMP标识符都将被字符串“1.02”替换掉。 以下是另一个宏定义的例子： #define CUBE(x)((x)，(x)*(x)) 上例中定义了一个名为CUBE的宏，它有一个参数x。CUBE宏有自己的宏体，即((x)*(x)*(x))——在编译预处理时，源代码中的每个CUBE(x)宏都将被((x)*(x)*(x))替换掉。 使用宏有以下几点好处： (1)在输入源代码时，可省去许多键入操作。 (2)因为宏只需定义一次，但可以多次使用，所以使用宏能增强程序的易读性和可靠性。 (3)使用宏不需要额外的开销，因为宏所代表的代码只在宏出现的地方展开，因此不会引起程序中的跳转。 (4)宏的参数对类型不敏感，因此你不必考虑将何种数据类型传递给宏。 需要注意的是，在宏名和括起参数的括号之间绝对不能有空格。此外，为了避免在翻译宏时产生歧义，宏体也应该用括号括起来。例如，象下例中这样定义CUBE宏是不正确的： denne CUBE(x) x * x * x 对传递给宏的参数也要小心，例如，一种常见的错误就是将自增变量传递给宏，请看下例： #include <stdio. h> #include CUBE(x) (x * x * x) void main (void); void main (void){int x, y;x = 5;y = CUBE( + +x); printfC'y is %d\n" . y);}在上例中，y究竟等于多少呢?实际上，y既不等于125(5的立方)，也不等于336(6* 7*8)，而是等于512。因为变量x被作为参数传递给宏时进行了自增运算，所以上例中的CUBE宏实际上是按以下形式展开的： y = ((++x) * (++x) * (++x))； 这样，每次引用x时，x都要自增，所以你得到的结果与你预期的结果相差很远，在上例中，由于x被引用了3次，而且又使用了自增运算符，因此，在展开宏的代码时，x实际上为8，你将得到8的立方，而不5的立方。 上述错误是比较常见的，作者曾亲眼见过有多年C语言编程经验的人犯这种错误。因为在程序中检查这种错误是非常费劲的，所以你要给予充分的注意。你最好试一下上面的例子，亲眼看一下那个令人惊讶的结果值(512)。 宏也可使用一些特殊的运算符，例如字符串化运算符“#”和。连接运算符“##”。“#”运算符能将宏的参数转换为带双引号的字符串，请看下例： define DEBUG_VALUE(v) printf(#v"is equal to %d．\n"，v) 你可以在程序中用DEBUG_VALUE宏检查变量的值，请看下例: int x＝20； DEBUG_VALUE(x); 上述语句将在屏幕上打印"x is equal to 20"。这个例子说明，宏所使用的“#”运算符是一种非常方便的调试工具。 “##”运算符的作用是将两个独立的字符串连接成一个字符串。
㈦ 编程中宏的用法
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 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)))
[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)
宏中#和##的用法
一、一般用法
我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起.
用法
#includecstdio
#includeclimits
using namespace std;
#define STR(s) #s
#define CONS(a,b) int(a##e##b)
int main()
{
printf(STR(vck)); 输出字符串vck
printf(%dn, CONS(2,3)); 2e3 输出2000
return 0;
}
二、当宏参数是另一个宏的时候
需要注意的是凡宏定义里有用''#''或''##''的地方宏参数是不会再展开.
1, 非''#''和''##''的情况
#define TOW (2)
#define MUL(a,b) (ab)
printf(%d%d=%dn, TOW, TOW, MUL(TOW,TOW));
这行的宏会被展开为：
printf(%d%d=%dn, (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 %sn, STR(INT_MAX)); INT_MAX #includeclimits
这行会被展开为：
printf(int max %sn, INT_MAX);
printf(%sn, CONS(A, A)); compile error
这一行则是：
printf(%sn, 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 %sn, STR(INT_MAX)); INT_MAX,int型的最大值,为
一个变量 #includeclimits
输出为 int max 0x7fffffff
STR(INT_MAX) -- _STR(0x7fffffff) 然后再转换成字符串;
printf(%dn, CONS(A, A));
输出为：200
CONS(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）属于编译器预处理的范畴，
属于编译期概念（而非运行期概念）。下面对常遇到的宏的使用问题做了简单
总结。
关于#和##
在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）。
㈧ C语言的宏(macro)是什么怎样使用宏
#define VERSION—STAMP "1．02" 上例中所定义的这种形式的宏通常被称为标识符。在上例中，标识符VERSION_STAMP即代表字符串"1．02"——在编译预处理时，源代码中的每个VERSION_STAMP标识符都将被字符串“1.02”替换掉。 以下是另一个宏定义的例子： #define CUBE(x)((x)，(x)*(x)) 上例中定义了一个名为CUBE的宏，它有一个参数x。CUBE宏有自己的宏体，即((x)*(x)*(x))——在编译预处理时，源代码中的每个CUBE(x)宏都将被((x)*(x)*(x))替换掉。 使用宏有以下几点好处： (1)在输入源代码时，可省去许多键入操作。 (2)因为宏只需定义一次，但可以多次使用，所以使用宏能增强程序的易读性和可靠性。 (3)使用宏不需要额外的开销，因为宏所代表的代码只在宏出现的地方展开，因此不会引起程序中的跳转。 (4)宏的参数对类型不敏感，因此你不必考虑将何种数据类型传递给宏。 需要注意的是，在宏名和括起参数的括号之间绝对不能有空格。此外，为了避免在翻译宏时产生歧义，宏体也应该用括号括起来。例如，象下例中这样定义CUBE宏是不正确的： denne CUBE(x) x * x * x 对传递给宏的参数也要小心，例如，一种常见的错误就是将自增变量传递给宏，请看下例： #include #include CUBE(x) (x * x * x) void main (void); void main (void){int x, y;x = 5;y = CUBE( + +x); printfC'y is %d\n" . y);}在上例中，y究竟等于多少呢?实际上，y既不等于125(5的立方)，也不等于336(6* 7*8)，而是等于512。因为变量x被作为参数传递给宏时进行了自增运算，所以上例中的CUBE宏实际上是按以下形式展开的： y = ((++x) * (++x) * (++x))； 这样，每次引用x时，x都要自增，所以你得到的结果与你预期的结果相差很远，在上例中，由于x被引用了3次，而且又使用了自增运算符，因此，在展开宏的代码时，x实际上为8，你将得到8的立方，而不5的立方。 上述错误是比较常见的，作者曾亲眼见过有多年C语言编程经验的人犯这种错误。因为在程序中检查这种错误是非常费劲的，所以你要给予充分的注意。你最好试一下上面的例子，亲眼看一下那个令人惊讶的结果值(512)。 宏也可使用一些特殊的运算符，例如字符串化运算符“#”和。连接运算符“##”。“#”运算符能将宏的参数转换为带双引号的字符串，请看下例： define DEBUG_VALUE(v) printf(#v"is equal to %d．\n"，v) 你可以在程序中用DEBUG_VALUE宏检查变量的值，请看下例: int x＝20； DEBUG_VALUE(x); 上述语句将在屏幕上打印"x is equal to 20"。这个例子说明，宏所使用的“#”运算符是一种非常方便的调试工具。 “##”运算符的作用是将两个独立的字符串连接成一个字符串。
㈨ 【C语言】变量/常量/宏定义
变量和常量是程序处理的两种基本数据对象
变量的意义就是确定目标并提供存放的空间。
1.变量名只能是英文字母（A-Z，a-z）和数字（0-9）或者下划线 _ 组成。
2.第一个字母必须是字母或者下划线开头。
3.变量名区分大小写。
4.不能使用关键字来命名。
-关键字列表
1.char
-字符型，占用一个字节。
2.int
-整型，通常反映了所用机器语言中整数的最自然长度。
3.float
-单精度浮点型。
4.double
-双精度浮点型。
数据类型 变量名
-int a
-char b
-float c
-double d
1.整型常量：520、1314、123
2.实型常量：3.14、5.12、8.97
3.字符常量：
-普通字符：'L'，'O'，'v'，'e'
-转义字符：'\n'，'\t'，'\b'
4.字符串常量："demo"
字符：'A'，'b'
字符串：'Hello world' 编译器在编译的时候会给他加上一个转义字符 '\0' 空字符表示字符串的结束，故这个字符串有12个字符。
5.符号常量：使用前必须先定义
-定义符号常量 （宏定义）
格式：#define 标识符 常量
例如：
标识符（identifier）【有意思的是标识符念作biao fu】
1.标识符只能是英文字母（A-Z，a-z）和数字（0-9）或者下划线（_）组成。
2.必须以字母或下划线开头。
3.标识符区分大小写。
4.不能使用关键字来命名标识符。