码迷,mamicode.com
首页 > 其他好文 > 详细

#define与typedef

时间:2015-09-25 11:12:17      阅读:190      评论:0      收藏:0      [点我收藏+]

标签:

#define(宏定义)只是简单的字符串代换(原地扩展),它本身并不在编译过程中进行,而是在这之前(预处理过程)就已经完成了。

typedef是为了增加可读性而为标识符另起的新名称(仅仅只是个别名),它的新名字具有一定的封装性,以致于新命名的标识符具有更易定义变量的功能,它是语言编译过程的一部分,但它并不实际分配内存空间。

 

一般都遵循#define定义“可读”的常量以及一些宏语句的任务,而typedef则常用来定义关键字、冗长的类型的别名。

 

typedef是语句( 以‘;‘结尾),而#define不是语句( 不以‘;‘结尾)

 

typedef      (int*)        pINT;
以及下面这行:
#define      pInt      int*

效果相同?实则不同!

实践中见差别:

pINT a,b;的效果同int * a; int * b; 表示定义了两个整型指针变量a和b;

pInt a,b;的效果同int * a; int b; 表示定义一个整型指针变量a和一个整形变量b;

#define与const区别(定义常量):

1. const常量有数据类型,而#define(宏)常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会产生意料不到的错误(边际效应)。

2. const常量在堆栈分配了空间,而#define(宏)常量只是把具体数值直接传递到目标变量罢了。或者说,const的常量是一个Run-Time的概念,他在程序中确确实实的存在并可以被调用、传递。而#define常量则是一个Compile-Time概念,它的生命周期止于编译期:在实际程序中他只是一个常数、一个命令中的参数,没有实际的存在。

3. const常量存在于程序的数据段,#define常量存在于程序的代码段。

4. 有些集成化的调试工具可以对const常量进行调试,但是不能对宏常量进行调试。

 

 

#define的用法:

1、简单的宏定义

#define MAXTIME 1000

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

if(i<MAXTIME){
技术分享技术分享技术分享
}

编译器在处理这个代码之前会对MAXTIME进行处理替换为1000。
这样的定义看起来类似于普通的常量定义const,但也有着不同,因为define的定义只是简单的替换,而不是作为一个量来使用,这个问题在下面反映的尤为突出。

2、带参数的宏
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 int_ptr int *;
int_ptr a,b;

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

int* a,b;

a是int型指针,而b是int型变量。这时应该使用typedef定义:

typedef int* int_ptr;
int_ptr a,b;

这样a和b就都是int型指针了。

3、define的多行定义
define可以替代多行的代码,例如MFC中的宏定义(非常的经典,虽然让人看了恶心)

 
#define MACRO(arg1, arg2) do { /
/* declarations */ /
stmt1; /
stmt2; /
/*  */ /
} while(0) /* (no trailing ; ) */

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

技术分享
#ifdef WINDOWS
......
......
#endif
#ifdef LINUX
......
......
#endif

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

5、如何定义宏、取消宏

//定义宏
#define [MacroName] [MacroValue]
//取消宏
#undef [MacroName]
//普通宏
#define PI (3.1415926)
//带参数的宏
#define max(a,b) ((a)>(b)? (a),(b))

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

6、条件编译
#ifdef XXX…(#else) …#endif
例如:

 
#ifdef DV22_AUX_INPUT
#define AUX_MODE 3
#else
#define AUY_MODE 3
#endif

#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不是简单替换 ,而是采用如同定义变量的方法那样来声明一种类型。重复前面的例子:

#define int_ptr int *
int_ptr a,b; //相当于int * a, b; 只是简单的宏替换,a是整型指针,而b之是整型变量
typedef int * int_ptr;
int_ptr a,b; //a, b 都为指向int的指针,typedef为int* 引入了一个新的助记符

4、也许您已经注意到#define不是语句,不要在行末加分号,否则会连分号一块置换;但是typedef结束必须加分号,因为它是语句。

 

typedef的四个用途和两个陷阱

用途一: 
定义一种类型的别名,而不只是简单的宏替换。可以用作同时声明指针型的多个对象。比如: 

char*     pa,     pb;       //     这多数不符合我们的意图,它只声明了一个指向字符变量的指针,   
//     和一个字符变量; 

以下则可行: 

typedef     char*     PCHAR;       //     一般用大写 
PCHAR     pa,     pb;                   //     可行,同时声明了两个指向字符变量的指针 

虽然: 

char     *pa,     *pb; 

也可行,但相对来说没有用typedef的形式直观,尤其在需要大量指针的地方,typedef的方式更省事。 

用途二: 
用在旧的C代码中(具体多旧没有查),帮助struct。以前的代码中,声明struct新对象时,必须要带上struct,即形式为:     struct     结构名     对象名,如: 

struct     tagPOINT1 
{ 
          int     x; 
          int     y; 
}; 
struct     tagPOINT1     p1;   

而在C++中,则可以直接写:结构名     对象名,即: 

tagPOINT1     p1; 

估计某人觉得经常多写一个struct太麻烦了,于是就发明了: 

typedef     struct     tagPOINT 
{ 
          int     x; 
          int     y; 
}POINT; 

POINT     p1;     //     这样就比原来的方式少写了一个struct,比较省事,尤其在大量使用的时候 

或许,在C++中,typedef的这种用途二不是很大,但是理解了它,对掌握以前的旧代码还是有帮助的,毕竟我们在项目中有可能会遇到较早些年代遗留下来的代码。 

用途三: 
用typedef来定义与平台无关的类型。 
比如定义一个叫     REAL     的浮点类型,在目标平台一上,让它表示最高精度的类型为: 

typedef     long     double     REAL;  

在不支持     long     double     的平台二上,改为: 

typedef     double     REAL;   

在连     double     都不支持的平台三上,改为: 

typedef     float     REAL;   

也就是说,当跨平台时,只要改下     typedef     本身就行,不用对其他源码做任何修改。 
标准库就广泛使用了这个技巧,比如size_t。 
另外,因为typedef是定义了一种类型的新别名,不是简单的字符串替换,所以它比宏来得稳健(虽然用宏有时也可以完成以上的用途)。 

用途四: 
为复杂的声明定义一个新的简单的别名。方法是:在原来的声明里逐步用别名替换一部分复杂声明,如此循环,把带变量名的部分留到最后替换,得到的就是原声明的最简化版。举例: 

1.     原声明:int     *(*a[5])(int,     char*); 
变量名为a,直接用一个新别名pFun替换a就可以了: 

typedef     int     *(*pFun)(int,     char*);   

原声明的最简化版: 

pFun     a[5]; 

2.     原声明:void     (*b[10])     (void     (*)()); 
变量名为b,先替换右边部分括号里的,pFunParam为别名一: 

typedef     void     (*pFunParam)(); 

再替换左边的变量b,pFunx为别名二: 

typedef     void     (*pFunx)(pFunParam); 

原声明的最简化版: 

pFunx     b[10]; 

3.     原声明:doube(*)()     (*e)[9];   
变量名为e,先替换左边部分,pFuny为别名一: 

typedef     double(*pFuny)(); 

再替换右边的变量e,pFunParamy为别名二 

typedef     pFuny     (*pFunParamy)[9]; 

原声明的最简化版: 

pFunParamy     e;   

理解复杂声明可用的“右左法则”:从变量名看起,先往右,再往左,碰到一个圆括号就调转阅读的方向;括号内分析完就跳出括号,还是按先右后左的顺序,如此循环,直到整个声明分析完。举例: 

int     (*func)(int     *p); 

首先找到变量名func,外面有一对圆括号,而且左边是一个*号,这说明func是一个指针;然后跳出这个圆括号,先看右边,又遇到圆括号,这说明 (*func)是一个函数,所以func是一个指向这类函数的指针,即函数指针,这类函数具有int*类型的形参,返回值类型是int。 

int     (*func[5])(int     *); 

func右边是一个[]运算符,说明func是具有5个元素的数组;func的左边有一个*,说明func的元素是指针(注意这里的*不是修饰func, 而是修饰func[5]的,原因是[]运算符优先级比*高,func先跟[]结合)。跳出这个括号,看右边,又遇到圆括号,说明func数组的元素是函数 类型的指针,它指向的函数具有int*类型的形参,返回值类型为int。 

也可以记住2个模式: 
type     (*)(....)函数指针   
type     (*)[]数组指针   


陷阱一: 
记住,typedef是定义了一种类型的新别名,不同于宏,它不是简单的字符串替换。比如: 
先定义: 

typedef     char*     PSTR; 

然后: 

int     mystrcmp(const     PSTR,     const     PSTR); 


const     PSTR实际上相当于const     char*吗?不是的,它实际上相当于char*     const。 
原因在于const给予了整个指针本身以常量性,也就是形成了常量指针char*     const。 
简单来说,记住当const和typedef一起出现时,typedef不会是简单的字符串替换就行。 

陷阱二: 
typedef在语法上是一个存储类的关键字(如auto、extern、mutable、static、register等一样),虽然它并不真正影响对象的存储特性,如: 

typedef     static     int     INT2;     //不可行 

编译将失败,会提示“指定了一个以上的存储类”。

#define与typedef

标签:

原文地址:http://www.cnblogs.com/shmilxu/p/4837435.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!