[define的用法]define用法集锦

篇一 : define用法集锦

Definition：

The #define Directive

You can use the #define directive to give a meaningful name to a constant in your program. The two forms of the syntax are:

Syntax

#define identifier token-stringopt

#define identifier[( identifieropt, ... , identifieropt )] token-stringopt

Usage：

1. 简单的define定义

#define MAXTIME 1000

一个简单的MAXTIME就定义好了，它代表1000，如果在程序里面写

if(i<MAXTIME){.........}

编译器在处理这个代码之前会对MAXTIME进行处理替换为1000。[www.t262.com）

这样的定义看起来类似于普通的常量定义CONST，但也有着不同，因为define的定义更像是简单的文本替换，而不是作为一个量来使用，这个问题在下面反映的尤为突出。

2.define的“函数定义”

define可以像函数那样接受一些参数，如下

#define max(x,y) （(x)>(y)?(x):(y)）;

这个定义就将返回两个数中较大的那个，看到了吗？因为这个“函数”没有类型检查，就好像一个函数模板似的，当然，它绝对没有模板那么安全就是了。可以作为一个简单的模板来使用而已。

但是这样做的话存在隐患，例子如下：

#define Add(a,b) a+b;

在一般使用的时候是没有问题的，但是如果遇到如：c * Add(a,b) * d的时候就会出现问题，代数式的本意是a+b然后去和c，d相乘，但是因为使用了define（它只是一个简单的替换），所以式子实际上变成了

c*a + b*d

另外举一个例子：

#define pin (int*);

pin a,b;

本意是a和b都是int型指针，但是实际上变成int* a,b;

a是int型指针，而b是int型变量。

这是应该使用typedef来代替define，这样a和b就都是int型指针了。

所以我们在定义的时候，养成一个良好的习惯，建议所有的层次都要加括号。

3.宏的单行定义（少见用法）

#define A(x) T_##x

#define B（x) #@x

#define C（x) #x

我们假设：x=1，则有：

A(1)------〉T_1

define define用法集锦

B(1)------〉'1'

C(1)------〉"1"

（这里参考了 hustli的文章）

3.define的多行定义

define可以替代多行的代码，例如MFC中的宏定义（非常的经典，虽然让人看了恶心）但是如果只有一个语句，完全没有必要用do while

#define MACRO(arg1, arg2) do { \

\

stmt1; \

stmt2; \

\

} while(0)

关键是要在每一个换行的时候加上一个"\"

如果你想在宏中包含多个语句,可能会这样写:

#define do_something() \

do_a(); \

do_b();

这样你就可以用 do_somethin() 来执行一系列操作.

但这样会有个问题: 如果你下面这样用这个宏地话:

if (...)

do_something();

当宏被展开后就变成:

if (...)

do_a();

do_b();

发现问题没? 原代码的目的是想在 if 为真的时候执行 do_a() 和 do_b(), 但现在呢? 只有 do_a() 在条件语句中, do_b() 任何时候都会执行的.

这时你可能会将那个宏改进一下:

#define do_something() { \

do_a(); \

do_b(); \

}

看样子行了, 是吗? 如果我这个宏是这个样子的呢:

#define do_something() { \

define define用法集锦

if (a) \

do_a(); \

else \

do_b();

}

这么使用:

if (...)

do_something();

else {

...

}

宏展开后:

if (...)

{

if (a)

do_a();

else

do_b();

}; else {

}

注意到第二个 else 前边那个分号了吗?

所以有人想到了用 do { } while (0) 来解决这个问题, do {} while 语句是需要分号来结束的, 另外, 现代编译器的优化模块能够足够聪明地注意到这个循环只会执行一次而将其优化掉.

综上所述, do { } while(0) 这个技术就是为了类似的宏可以在任何时候使用.

注: 如果你看过 linux 内核源代码, 这个技巧非常常见

4.在大规模的开发过程中，特别是跨平台和系统的软件里，define最重要的功能是条件编译。(www.t262.com) 就是：

#ifdef WINDOWS

......

......

#endif

#ifdef LINUX

......

......

define define用法集锦

#endif

可以在编译的时候通过#define设置编译环境

5.如何定义宏、取消宏

//定义宏

#define [MacroName] [MacroValue]

//取消宏

#undef [MacroName]

//普通宏

#define PI (3.1415926)

带参数的宏

#define max(a,b) （((a)>(b)? (a),(b))）

关键是十分容易产生错误，包括机器和人理解上的差异等等。（www.t262.com]

6.条件编译

#ifdef XXX?(#else) ? #endif

例如

#ifdef DV22_AUX_INPUT

#define AUX_MODE 3

#else

#define AUY_MODE 3

#endif

#ifndef XXX ? (#else) ? #endif

7.头文件(.h)可以被头文件或C文件包含；

重复包含（重复定义）

由于头文件包含可以嵌套，那么C文件就有可能包含多次同一个头文件，就可能出现重复定义的问题的。 通过条件编译开关来避免重复包含（重复定义）

例如

#ifndef __headerfileXXX__

#define __headerfileXXX__

?

//文件内容

?

#endif

define define用法集锦

Instances：

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

#ifndef COMDEF_H

#define COMDEF_H

//头文件内容

#endif

2、重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。（www.t262.com） typedef unsigned char boolean;

typedef unsigned long int uint32;

typedef unsigned short uint16;

typedef unsigned char uint8;

typedef signed long int int32;

typedef signed short int16;

typedef signed char int8;

//下面的不建议使用

typedef unsigned char byte;

typedef unsigned short word;

typedef unsigned long dword;

typedef unsigned char uint1;

typedef unsigned short uint2;

typedef unsigned long uint4;

typedef signed char int1;

typedef signed short int2;

typedef long int int4;

typedef signed long sint31;

typedef signed short sint15;

typedef signed char sint7;

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 )

define define用法集锦

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 define用法集锦

#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、使用一些宏跟踪调试

ANSI标准说明了五个预定义的宏名。［www.t262.com）它们是：

__LINE__

__FILE__

__DATE__

__TIME__

__STDC__

C++中还定义了 __cplusplus

如果编译器不是标准的,则可能仅支持以上宏名中的几个,或根本不支持。记住编译程序也许还提供其它预定义的宏名。

__LINE__ 及 __FILE__ 宏指示，#line指令可以改变它的值，简单的讲，编译时，它们包含程序的当前行数和文件名。

__DATE__ 宏指令含有形式为月/日/年的串,表示源文件被翻译到代码时的日期。

__TIME__ 宏指令包含程序编译的时间。时间用字符串表示，其形式为：分：秒

__STDC__ 宏指令的意义是编译时定义的。一般来讲，如果__STDC__已经定义，编译器将仅接受不包含任何非标准扩展的标准C/C++代码。如果实现是标准的,则宏__STDC__含有十进制常量1。如果它含有任何其它数,则实现是非标准的。

__cplusplus 与标准c++一致的编译器把它定义为一个包含至少6为的数值。与标准c++不一致的编译器将使用具有5位或更少的数值。

可以定义宏,例如:

当定义了_DEBUG,输出数据信息和所在文件所在行

#ifdef _DEBUG

#define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%d”,date,_LINE_,_FILE_)

#else

#define DEBUGMSG(msg,date)

#endif

20、宏定义防止错误使用小括号包含。

例如：

有问题的定义：#define DUMP_WRITE(addr,nr) {memcpy(bufp,addr,nr); bufp += nr;}

应该使用的定义： #difne DO(a,b) do{a+b;a++;}while(0)

例如：

if(addr)

DUMP_WRITE(addr,nr);

else

do_somethong_else();

宏展开以后变成这样:

if(addr)

{memcpy(bufp,addr,nr); bufp += nr;};

else

define define用法集锦

do_something_else();

gcc在碰到else前面的“；”时就认为if语句已经结束，因而后面的else不在if语句中。［www.t262.com]而采用do{} while(0)的定义，在任何情况下都没有问题。而改为 #difne DO(a,b) do{a+b;a++;}while(0) 的定义则在任何情况下都不会出错

21. define中的特殊标识符

#define Conn(x,y) x##y

#define ToChar(x) #@x

#define ToString(x) #x

int a=Conn(12,34);

char b=ToChar(a);

char c[]=ToString(a);

结果是 a=1234,c='a',c='1234';

可以看出 ## 是简单的连接符，#@用来给参数加单引号，#用来给参数加双引号即转成字符串

篇二 : define：define-参数，define-作用

define，无参宏定义的一般形式为：#define 标识符 字符串。define() 函数定义一个常量。正如C语言中所讲，函数的使用可以使程序更加模块化，便于组织，而且可重复利用，但在发生函数调用时，需要保留调用函数的现场，以便子函数执行结束后能返回继续执行，同样在子函数执行完后要恢复调用函数的现场，这都需要一定的时间，如果子函数执行的操作比较多，这种转换时间开销可以忽略，但如果子函数完成的功能比较少，甚至于只完成一点操作，如一个乘法语句的操作，则这部分转换开销就相对较大了，但使用带参数的宏定义就不会出现这个问 题，因为它是在预处理阶段即进行了宏展开，在执行时不需要转换，即在当地执行。

define_define -参数

#define GPEBLT_FUNCNAME(basename) (SCODE (GPE::*)(struct GPEBltParms *))&GPE::##basename

在#define中，标准只定义了#和##2种操作。#用来把参数转换成字符串，##则用来连接前后2个参数，把它们变成1个字符串。

输出为:token 9 = 10

详见百科typedef（相似）。

define_define -作用

被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，这称为“宏代换”或“宏展开”。宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。

宏定义的作用范围仅限于当前文件，即file1.c中定义 #define PI 3.14，在file2.c中该宏定义不起作用；通过将#define PI 3.14定义在common.h中，file1.c和file2.c分别#include "common.h"的方式，该宏定义在file1.c和file2.c中都起作用。

在C或C++语言中，“宏”分为有参数和无参数2种。

define_define -宏定义优点

(1) 方便程序的修改

使用简单宏定义可用宏代替1个在程序中经常使用的常量，这样在将该常量改变时，不用对整个程序进行修改，只修改宏定义的字符串就可以，而且当常量比较长时， 我们可以用较短的有意义的标识符来写程序，这样更方便一些。我们所说的常量改变不是在程序运行期间改变，而是在编程期间的修改，举1个大家比较熟悉的例 子，圆周率π是在数学上常用的1个值，有时我们会用3.14来表示，有时也会用3.1415926等，这要看计算所需要的精度，如果我们编制的1个程序中 要多次使用它，那么需要确定1个数值，在本次运行中不改变，但也许后来发现程序所表现的精度有变化，需要改变它的值， 这就需要修改程序中所有的相关数值，这会给我们带来一定的不便，但如果使用宏定义，使用1个标识符来代替，则在修改时只修改宏定义就可以，还可以减少输入 3.1415926这样长的数值多次的情况，我们可以如此定义 #define pi 3.1415926，既减少了输入又便于修改，何乐而不为呢？

(2) 提高程序的运行效率

使用带参数的宏定义可完成函数调用的功能，又能减少系统开销，提高运行效率。正如C语言中所讲，函数的使用可以使程序更加模块化，便于组织，而且可重复利用，但在发生函数调用时，需要保留调用函数的现场，以便子函数执行结束后能返回继续执行，同样在子函数执行完后要恢复调用函数的现场，这都需要一定的时间，如果子函数执行的操作比较多，这种转换时间开销可以忽略，但如果子函数完成的功能比较少，甚至于只完成一点操作，如1个乘法语句的操作，则这部分转换开销就相对较大了，但使用带参数的宏定义就不会（www.t262.com]出现这个问 题，因为它是在预处理阶段即进行了宏展开，在执行时不需要转换，即在当地执行。宏定义可完成简单的操作，但复杂的操作还是要由函数调用来完成，而且宏定义所占用的目标代码空间相对较大。所以在使用时要依据具体情况来决定是否使用宏定义。

define_define -无参宏定义

无参宏定义的一般形式为：#define 标识符 字符串

其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。

例如：#define M (a+b)它的作用是指定标识符M来代替表达式(a+b)。在编写源程序时，所有的(a+b)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(a+b)表达式去置换所有的宏名M，然后再进行编译。

程序1：

上例程序中首先进行宏定义，定义M来替代表达式(a+b),在 s= M * M 中作了宏调用。在预处理时经宏展开后该语句变为： S=(a+b)*(a+b) 但要注意的是，在宏定义中表达式(a+b)两边的括号不能少。否则会发生错误。 如当作以下定义后：#define M (a)+(b) 在宏展开时将得到下述语句：S= (a)+(b)*(a)+(b)

对于宏定义还要说明以下几点：

1.宏定义是用宏名来表示1个字符串，在宏展开时又以该字符串取代宏名，这只是1种简单的代换，字符串中可以含任何字符，可以是常数，也可以是表达式，预处理程序对它不作任何检查。如有错误，只能在编译已被宏展开后的源程序时发现。

2.宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号也一起置换。

3.宏定义其作用域为宏定义命令起到源程序结束。如要终止其作用域可使用#undef命令。 （有关#undef 请查阅其他资料）

define_define -带参宏定义

c语言允许宏带有参数。在宏定义中的参数称为形式参数，在宏调用中的参数称为实际参数。对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。

带参宏定义的一般形式为： #define 宏名(形参表) 字符串

在字符串中含有各个形参。 带参宏调用的一般形式为： 宏名(形参表)

例如：

在宏调用时，用实参5去代替形参y，经预处理宏展开后的语句为: k=5*5+3*5

程序2：

上例程序的第一行进行带参宏定义，用宏名MAX表示条件表达式 (a>b)?a:b ，形参a,b均出现在条件表达式中。程序中 max=MAX(x,y) 为宏调用，实参x,y，将代换形参a,b。宏展开后该语句为： max=(x>y)?x:y; 用于计算x,y中的大数。

#define 条件编译

头文件(.h)可以被头文件或C文件包含；重复包含（重复定义）由于头文件包含可以嵌套，那么C文件就有可能包含多次同1个头文件，就可能出现重复定义的问题的。 通过条件编译开关来避免重复包含（重复定义）

例如

详见百科#typedef（相似）

define_define -PHP用法

define() 函数定义1个常量。

常量类似变量，不同之处在于：

在设定以后，常量的值无法更改

常量名不需要开头的美元符号 ($)

作用域不影响对常量的访问

常量值只能是字符串或数字

define_define -例子

例子1

定义1个大小写敏感的常量：

输出：

Hello world!

例子2

定义1个大小写不敏感的常量：

输出：

Hello world!

转自：