typedef是什么意思

　　typedef是在计算机编程语言中用来为复杂的声明定义简单的别名，与宏定义有些差异。它本身是一种存储类的关键字，与auto、extern、mutable、staTIc、register等关键字不能出现在同一个表达式中。

　　typedef 行为有点像 #define 宏，用其实际类型替代同义字。不同点是 typedef 在编译时被解释，因此让编译器来应付超越预处理器能力的文本替换。例如：

　　typedef int （*PF） （const char *， const char *）;

　　这个声明引入了 PF 类型作为函数指针的同义字，该函数有两个 const char * 类型的参数以及一个 int 类型的返回值。如果要使用下列形式的函数声明，那么上述这个 typedef 是不可或缺的：

　　PF Register（PF pf）;

　　Register（） 的参数是一个 PF 类型的回调函数，返回某个函数的地址，其署名与先前注册的名字相同。做一次深呼吸。下面我展示一下如果不用 typedef，我们是如何实现这个声明的：

　　int （*Register （int （*pf）（const char *， const char *）））

　　（const char *， const char *）;

　　很少有程序员理解它是什么意思，更不用说这种费解的代码所带来的出错风险了。显然，这里使用 typedef 不是一种特权，而是一种必需。持怀疑态度的人可能会问：“OK，有人还会写这样的代码吗？”，快速浏览一下揭示 signal（）函数的头文件 ，一个有同样接口的函数。注意这里Register被定义为一个函数而不是函数指针，如果要定义为函数指针应该这样写：int （*（*Register） （int （*pf）（const char *， const char *））） （const char *， const char *）;

　　typedef 和存储类关键字（storage class specifier）

　　这种说法是不是有点令人惊讶，typedef 就像 auto，extern，mutable，staTIc，和 register 一样，是一个存储类关键字。这并不是说 typedef 会真正影响对象的存储特性；它只是说在语句构成上，typedef 声明看起来象 staTIc，extern 等类型的变量声明。下面将带到第二个陷阱：

　　typedef register int FAST_COUNTER; // 错误

　　编译通不过。问题出在你不能在声明中有多个存储类关键字。因为符号 typedef 已经占据了存储类关键字的位置，在 typedef 声明中不能用 register（或任何其它存储类关键字）。

　　typedef的四个用途

　　用途一：

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

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

　　// 和一个字符变量；

　　以下则可行：

　　typedef char* PCHAR; // 一般用大写

　　PCHAR pa， pb; // 可行，同时声明了两个指向字符变量的指针

　　虽然：

　　char *pa， *pb;

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

　　

　　用途二：

　　用在旧的C的代码中（具体多旧没有查），帮助struct。以前的代码中，声明struct新对象时，必须要带上struct，即形式为： struct 结构名 对象名，如：

　　［cpp］ view plain copystruct tagPOINT1

　　{

　　int x;

　　int y;

　　};

　　struct tagPOINT1 p1;

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

　　tagPOINT1 p1;

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

　　［cpp］ view plain copytypedef 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; //不可行

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

　　以上资料出自： http://blog.sina.com.cn/s/blog_4826f7970100074k.html 作者：赤龙

　　第三、typedef 与 #define的区别

　　案例一：

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

　　［cpp］ view plain copytypedef char *pStr1;

　　#define pStr2 char *;

　　pStr1 s1， s2;

　　pStr2 s3， s4;

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

　　案例二：

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

　　［cpp］ view plain copytypedef 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++错误。

　　第四部分资料：使用 typedef 抑制劣质代码

　　作者：Danny Kalev

　　编译：MTT 工作室

　　原文出处：Using typedef to Curb Miscreant Code

　　摘要： Typedef 声明有助于创建平台无关类型，甚至能隐藏复杂和难以理解的语法。不管怎样，使用 typedef 能为代码带来意想不到的好处，通过本文你可以学习用 typedef 避免缺欠，从而使代码更健壮。

　　typedef 声明，简称 typedef，为现有类型创建一个新的名字。比如人们常常使用 typedef 来编写更美观和可读的代码。所谓美观，意指 typedef 能隐藏笨拙的语法构造以及平台相关的数据类型，从而增强可移植性和以及未来的可维护性。本文下面将竭尽全力来揭示 typedef 强大功能以及如何避免一些常见的陷阱。

　　Q：如何创建平台无关的数据类型，隐藏笨拙且难以理解的语法？

　　A： 使用 typedefs 为现有类型创建同义字。

　　定义易于记忆的类型名

　　typedef 使用最多的地方是创建易于记忆的类型名，用它来归档程序员的意图。类型出现在所声明的变量名字中，位于 ‘’typedef‘’ 关键字右边。例如：

　　typedef int size;

　　此声明定义了一个 int 的同义字，名字为 size。注意 typedef 并不创建新的类型。它仅仅为现有类型添加一个同义字。你可以在任何需要 int 的上下文中使用 size：

　　void measure（size * psz）; size array［4］;size len = file.getlength（）;std：：vector 《size》 vs;

　　typedef 还可以掩饰符合类型，如指针和数组。例如，你不用象下面这样重复定义有 81 个字符元素的数组：

　　char line［81］;char text［81］;

　　定义一个 typedef，每当要用到相同类型和大小的数组时，可以这样：

　　typedef char Line［81］; Line text， secondline;getline（text）;

　　同样，可以象下面这样隐藏指针语法：

　　typedef char * pstr;int mystrcmp（pstr， pstr）;

　　这里将带我们到达第一个 typedef 陷阱。标准函数 strcmp（）有两个‘const char *’类型的参数。因此，它可能会误导人们象下面这样声明 mystrcmp（）：

　　int mystrcmp（const pstr， const pstr）;

　　这是错误的，按照顺序，‘const pstr’被解释为‘char * const’（一个指向 char 的常量指针），而不是‘const char *’（指向常量 char 的指针）。这个问题很容易解决：

　　typedef const char * cpstr; int mystrcmp（cpstr， cpstr）; // 现在是正确的

　　记住： 不管什么时候，只要为指针声明 typedef，那么都要在最终的 typedef 名称中加一个 const，以使得该指针本身是常量，而不是对象。

　　代码简化

　　上面讨论的 typedef 行为有点像 #define 宏，用其实际类型替代同义字。不同点是 typedef 在编译时被解释，因此让编译器来应付超越预处理器能力的文本替换。例如：

　　typedef int （*PF） （const char *， const char *）;

　　这个声明引入了 PF 类型作为函数指针的同义字，该函数有两个 const char * 类型的参数以及一个 int 类型的返回值。如果要使用下列形式的函数声明，那么上述这个 typedef 是不可或缺的：

　　PF Register（PF pf）;

　　Register（） 的参数是一个 PF 类型的回调函数，返回某个函数的地址，其署名与先前注册的名字相同。做一次深呼吸。下面我展示一下如果不用 typedef，我们是如何实现这个声明的：

　　int （*Register （int （*pf）（const char *， const char *））） （const char *， const char *）;

　　很少有程序员理解它是什么意思，更不用说这种费解的代码所带来的出错风险了。显然，这里使用 typedef 不是一种特权，而是一种必需。持怀疑态度的人可能会问：“OK，有人还会写这样的代码吗？”，快速浏览一下揭示 signal（）函数的头文件 《csinal》，一个有同样接口的函数。

　　typedef 和存储类关键字（storage class specifier）

　　这种说法是不 是有点令人惊讶，typedef 就像 auto，extern，mutable，static，和 register 一样，是一个存储类关键字。这并是说 typedef 会真正影响对象的存储特性；它只是说在语句构成上，typedef 声明看起来象 static，extern 等类型的变量声明。下面将带到第二个陷阱：

　　typedef register int FAST_COUNTER; // 错误

　　编译通不过。问题出在你不能在声明中有多个存储类关键字。因为符号 typedef 已经占据了存储类关键字的位置，在 typedef 声明中不能用 register（或任何其它存储类关键字）。

　　促进跨平台开发

　　typedef 有另外一个重要的用途，那就是定义机器无关的类型，例如，你可以定义一个叫 REAL 的浮点类型，在目标机器上它可以i获得最高的精度：

　　typedef long double REAL;

　　在不支持 long double 的机器上，该 typedef 看起来会是下面这样：

　　typedef double REAL;

　　并且，在连 double 都不支持的机器上，该 typedef 看起来会是这样： 、

　　typedef float REAL;

　　你不用对源代码做任何修改，便可以在每一种平台上编译这个使用 REAL 类型的应用程序。唯一要改的是 typedef 本身。在大多数情况下，甚至这个微小的变动完全都可以通过奇妙的条件编译来自动实现。不是吗？ 标准库广泛地使用 typedef 来创建这样的平台无关类型：size_t，ptrdiff 和 fpos_t 就是其中的例子。此外，象 std：：string 和 std：：ofstream 这样的 typedef 还隐藏了长长的，难以理解的模板特化语法，例如：basic_string《char， char_traits《char》，allocator《char》》 和 basic_ofstream《char， char_traits《char》》。

　　以上转自：http://www.kuqin.com/language/20090322/41866.html

　　typedef & 结构的问题

　　（1）、typedef的最简单使用

　　typedef long byte_4;

　　给已知数据类型long起个新名字，叫byte_4。

　　（2）、 typedef与结构结合使用

　　typedef struct tagMyStruct

　　{

　　int iNum;

　　long lLength;

　　} MyStruct;

　　这语句实际上完成两个 *** 作：

　　1） 定义一个新的结构类型

　　struct tagMyStruct

　　{

　　int iNum;

　　long lLength;

　　};

　　分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。

　　我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。

　　2） typedef为这个新的结构起了一个名字，叫MyStruct。

　　typedef struct tagMyStruct MyStruct;

　　因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。

　　3）、规范做法：

　　struct tagNode

　　{

　　char *pItem;

　　struct tagNode *pNext;

　　};

　　typedef struct tagNode *pNode;

　　3. typedef & #define的问题

　　有下面两种定义pStr数据类型的方法，两者有什么不同？哪一种更好一点？

　　typedef char* pStr;

　　#define pStr char*;

　　答案与分析：

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

　　typedef char* pStr1;

　　#define pStr2 char *

　　pStr1 s1， s2;

　　pStr2 s3， s4;

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

　　上例中define语句必须写成 pStr2 s3， *s4; 这这样才能正常执行。

　　#define用法例子：

　　#define f（x） x*x

　　main（ ）

　　{

　　int a=6，b=2，c；

　　c=f（a） / f（b）；

　　printf（“%d //n ”，c）；

　　}

　　以下程序的输出结果是： 36。

　　因为如此原因，在许多C语言编程规范中提到使用#define定义时，如果定义中包含表达式，必须使用括号，则上述定义应该如下定义才对：

　　#define f（x） （x*x）

　　当然，如果你使用typedef就没有这样的问题。

　　4. typedef & #define的另一例

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

　　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++错误。

　　#define与typedef引申谈

　　1） #define宏定义有一个特别的长处：可以使用 #ifdef ，#ifndef等来进行逻辑判断，还可以使用#undef来取消定义。

　　2） typedef也有一个特别的长处：它符合范围规则，使用typedef定义的变量类型其作用范围限制在所定义的函数或者文件内（取决于此变量定义的位置），而宏定义则没有这种特性。

　　5. typedef & 复杂的变量声明

　　在编程实践中，尤其是看别人代码的时候，常常会遇到比较复杂的变量声明，使用typedef作简化自有其价值，比如：

　　下面是三个变量的声明，我想使用typdef分别给它们定义一个别名，请问该如何做？

　　》1：int *（*a［5］）（int， char*）;

　　》2：void （*b［10］） （void （*）（））;

　　》3. double（*）（） （*pa）［9］;

　　答案与分析：

　　对复杂变量建立一个类型别名的方法很简单，你只要在传统的变量声明表达式里用类型名替代变量名，然后把关键字typedef加在该语句的开头就行了。

　　》1：int *（*a［5］）（int， char*）;

　　//pFun是我们建的一个类型别名

　　typedef int *（*pFun）（int， char*）;

　　//使用定义的新类型来声明对象，等价于int* （*a［5］）（int， char*）;

　　pFun a［5］;

　　》2：void （*b［10］） （void （*）（） ）; // 此蓝色部分为个人理解，未找到原文出处

　　//首先为上面表达式蓝色部分声明一个新类型

　　typedef void （*pFunParam）（）;

　　//整体声明一个新类型

　　typedef void （*pFun）（pFunParam）;

　　//使用定义的新类型来声明对象，等价于void （*b［10］） （void （*）（））;

　　pFun b［10］;

　　》3. double（* （*pa）［9］ ）（）; // 此蓝色部分为个人理解，未找到原文出处

　　//首先为上面表达式蓝色部分声明一个新类型

　　typedef double（*pFun）（）;

　　//整体声明一个新类型

　　typedef pFun （*pFunParam）［9］;

　　//使用定义的新类型来声明对象，等价于double（*（*pa）［9］）（）;

　　pFunParam pa;