#define转录与总结

1、define中的三个特殊符号：#，##，##

#define Conn(x,y) x##y
#define ToChar(x)#@x
#define ToString(x)#x

(1)x##y表示什么？表示x连接y，举例说：

int n  = Conn(123,456);/* 结果就是n=123456;*/
char* str= Conn("asdf","adf");/*结果就是 str = "asdfadf";*/

（2）再来看 #@x ，其实就是给x加上单引号，结果返回是一个const char。举例说：

char a = ToChar(1);结果就是a='1';
做个越界试验char a = ToChar(123);结果就错了;
但是如果你的参数超过四个字符，编译器就给给你报错了！

error C2015: too many characters in constant   ：P

(3）最后看看#x,估计你也明白了，他是给x加双引号

char* str = ToString(123132);就成了str="123132";

 

#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"

2、 简单的define定义 

#define MAXTIME 1000

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

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

编译器在处理这个代码之前会对MAXTIME进行处理替换为1000。

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

 3、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型指针了。

******* 带参数的宏定义出现的问题

    在带参数的宏定义的使用中，极易引起误解。例如我们需要做个宏替换能求任何数的平方，这就需要使用参数，以便在程序中用实际参数来替换宏定义中的参数。一般学生容易写成如下形式：

#define area(x) x*x
/*这在使用中是很容易出现问题的，看如下的程序*/

void main()
{
    int y = area(2+2);
    printf(“%d”,y);
}

    按理说给的参数是2+2，所得的结果应该为4*4=16，但是错了，因为该程序的实际结果为8，仍然是没能遵循纯粹的简单替换的规则，又是先计算再替换 了， 在这道程序里，2+2即为area宏中的参数，应该由它来替换宏定义中的x，即替换成2+2*2+2=8了。那如果遵循(1)中的解决办法，把2+2 括起来，即把宏体中的x括起来，是否可以呢？#define area(x) (x)*(x)，对于area(2+2)，替换为(2+2)*(2+2)=16，可以解决， 但是对于area(2+2)/area(2+2)又会怎么样呢，有的学生一看到这道题马上给出结果，因为分子分母一样，又错了，还是忘了遵循先替换再计算的规则了，这道题替换后会变为 (2+2)*(2+2)/(2+2)*(2+2)即4*4/4*4按照乘除运算规则，结果为16/4*4=4*4=16，那应该怎么呢？解决方法是在整个宏体上再加一个括号，即 #define   area(x) ((x)*(x))， 不要觉得这没必要，没有它，是不行的。
    要想能够真正使用好宏定义，那么在读别人的程序时， 一定要记住先将程序中对宏的使用全部替换成它所代表的字符串，不要自作主张地添加任何其他符号，完全展开后再进行相应的计算，就不会写错运行结果。

    如果是自己编程使用宏替换，则在使用简单宏定义时，当字符串中不只一个符号时，加上括号表现出优先级，如果是带参数的宏定义，则要给宏体中的每个参数加上括号，并在整个宏体上再加一个括号。看到这里，不禁要问，用宏定义这么麻烦，这么容易出错，可不可以摒弃它， 那让我们来看一下在C语言中用宏定义的好处吧。

如：

#include <iostream.h>
#define product(x)    x*x
int main()
{
    int i=3;
    int j,k;
    j = product(i++);    cout<<"j="<<j<<endl;

    cout<<"i="<<i<<endl;

   k = product(++i);

   cout<<"k="<<k<<endl;
    cout<<"i="<<i<<endl;
    return 0;
}

依次输出结果：

j=9;i=5;k=49;i=7

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

4、define宏定义

define可以替代多行的代码，例如MFC中的宏定义（非常的经典，虽然让人看了恶心）

#define MACRO(arg1, arg2) do { \

/* declarations */ \

stmt1; \

stmt2; \

/* ... */ \

} while(0) /* (no trailing ; ) */

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

修补了几个bug

 5、条件编译

 在大规模的开发过程中，特别是跨平台和系统的软件里，define最重要的功能是条件编译。

就是：

#ifdef WINDOWS

......

......

#endif

#ifdef LINUX

......

......

#endif

 

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

 6、定义、取消

#define [MacroName] [MacroValue]

//取消宏

#undef [MacroName]

普通宏

#define PI (3.1415926)

 

带参数的宏

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

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

 7、条件编译

#ifdef XXX…(#else) …#endif

例如 #ifdef DV22_AUX_INPUT

#define AUX_MODE 3

#else

#define AUY_MODE 3

＃endif

#ifndef XXX … (#else) … #endif

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

重复包含（重复定义）

由于头文件包含可以嵌套，那么C文件就有可能包含多次同一个头文件，就可能出现重复定义的问题的。

通过条件编译开关来避免重复包含（重复定义）

例如

#ifndef __headerfileXXX__

＃define __headerfileXXX__

…

文件内容

…

#endif

 

以上只是我从网络上搜集了一些关于define的一些用法，可能还不全面，而且#define的使用本来也存在这争议，如果你对#define的用法也很有兴趣，可以来参加我们的讨论（点击下面的链接）

http://www.dingge.com/forum/dispbbs.asp?boardID=43&ID=6972&page=1

 9、#define和typedef的区别

1) #define是预处理指令，在编译预处理时进行简单的替换，不作正确性检查，不关含义是否正确照样带入，只有在编译已被展开的源程序时才会发现可能的错误并报错。例如：

#define PI 3.1415926

程序中的：area=PI*r*r 会替换为3.1415926*r*r

如果你把#define语句中的数字9 写成字母g 预处理也照样带入。

 

2）typedef是在编译时处理的。它在自己的作用域内给一个已经存在的类型一个别名，但是You cannot use the typedef specifier inside a function definition。

 

3）typedef int * int_ptr;

与

#define int_ptr int *

作用都是用int_ptr代表 int * ,但是二者不同，正如前面所说 ，#define在预处理 时进行简单的替换，而typedef不是简单替换，而是采用如同定义变量的方法那样来声明一种类型。也就是说;

 

//refer to (xzgyb(老达摩))

#define int_ptr int *

int_ptr a, b; //相当于int * a, b; 只是简单的宏替换

 

typedef int* int_ptr;

int_ptr a, b; //a, b 都为指向int的指针,typedef为int* 引入了一个新的助记符

 

这也说明了为什么下面观点成立

//QunKangLi(维护成本与程序员的创造力的平方成正比)

typedef int * pint ;

#define PINT int *

那么：

const pint p ;//p不可更改，但p指向的内容可更改

const PINT p ;//p可更改，但是p指向的内容不可更改。

 

pint是一种指针类型 const pint p 就是把指针给锁住了 p不可更改

而const PINT p 是const int * p 锁的是指针p所指的对象。

 

案例一：

通常讲，typedef要比#define要好，特别是在有指针的场合。请看例子：

typedef char *pStr1;

#define pStr2 char *;

pStr1 s1, s2;

pStr2 s3, s4;

在上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char，不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字。

案例二：

下面的代码中编译器会报一个错误，你知道是哪个语句错了吗？

typedef char * pStr;

char string[4] = "abc";

const char *p1 = string;

const pStr p2 = string;

p1++;

p2++;

是p2++出错了。这个问题再一次提醒我们：typedef和#define不同，它不是简单的文本替换。上述代码中const pStr p2并不等于const char * p2。const pStr p2和const long x本质上没有区别，都是对变量进行只读限制，只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已。因此，const pStr p2的含义是：限定数据类型为char *的变量p2为只读，因此p2++错误。

3）也许您已经注意到#define 不是语句 不要在行末加分号，否则 会连分号一块置换。

 

常用的一些宏定义

 

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

#ifndef BODYDEF_H
#define BODYDEF_H
 //头文件内容

#endif

 

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

 

#define MEM_B( x)( *((byte*)(x) ))
#define MEM_W( x)( *((word*)(x) ))

用法如下：

#include<iostream>
#include<windows.h>

#define MEM_B(x)(*((byte*)(x)))
#define MEM_W(x)(*((WORD*)(x)))

int main()
{
    int bTest  = 0x123456;

    byte m = MEM_B((&bTest));/*m=0x56*/
    int n = MEM_W((&bTest));/*n=0x3456*/

    return 0;
}

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

 

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

    请参考文章：详解写宏定义：得到一个field在结构体（struct type）中的偏移量。

 

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])))

11 使用一些宏跟踪调试

ANSI标准说明了五个预定义的宏名。它们是：

_LINE_ /*(两个下划线)，对应%d*/
_FILE_ /*对应%s*/
_DATE_ /*对应%s*/
_TIME_ /*对应%s*/