typedef用法

第一篇：typedef struct与struct的区别

1. 基本解释

typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。

在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。

至于typedef有什么微妙之处，请你接着看下面对几个问题的具体阐述。

2. typedef & 结构的问题

当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？莫非C语言不允许在结构中包含指向它自己的指针吗？请你先猜想一下，然后看下文说明：

typedef struct tagNode
{
　char *pItem;
　pNode pNext;
} *pNode;

答案与分析：

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来定义变量。

答案与分析

C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。

根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。

解决这个问题的方法有多种：

1)、

typedef struct tagNode 
{
　char *pItem;
　struct tagNode *pNext;
} *pNode;

2)、

typedef struct tagNode *pNode;
struct tagNode 
{
　char *pItem;
　pNode pNext;
};

注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。

3)、规范做法：

typedef uint32 (* ADM_READDATA_PFUNC)( uint16*, uint32 );

这个以前没有看到过,个人认为是宇定义一个uint32的指针函数,uint16*, uint32 为函数里的两个参数; 应该相当于#define uint32 (* ADM_READDATA_PFUNC)( uint16*, uint32 );

struct在代码中常见两种形式： 
struct A 
{ 
//... 
};

struct 
{ 
//... 
} A; 
这其实是两个完全不同的用法： 
前者叫做“结构体类型定义”，意思是：定义{}中的结构为一个名称是“A”的结构体。 
这种用法在typedef中一般是： 
typedef struct tagA //故意给一个不同的名字，作为结构体的实名 
{ 
//... 
} A; //结构体的别名。

后者是结构体变量定义，意思是：以{}中的结构，定义一个名称为"A"的变量。这里的结构体称为匿名结构体，是无法被直接引用的。 
也可以通过typedef为匿名结构体创建一个别名，从而使得它可以被引用： 
typedef struct 
{ 
//... 
} A; //定义匿名结构体的别名为A

第二篇：在C和C++中struct和typedef struct的区别

在C和C++有三种定义结构的方法。

typedef struct {

int data;

int text;

} S1;

//这种方法可以在c或者c++中定义一个S1结构

struct S2 {

int data;

int text;

};

// 这种定义方式只能在C++中使用，而如果用在C中，那么编译器会报错

struct {

int data;

int text;

} S3;

这种方法并没有定义一个结构，而是定义了一个s3的结构变量，编译器会为s3内存。

void main()

{

S1 mine1;// OK ,S1 是一个类型

S2 mine2;// OK,S2 是一个类型

S3 mine3;// OK,S3 不是一个类型

S1.data = 5;// ERRORS1 是一个类型

S2.data = 5;// ERRORS2 是一个类型

S3.data = 5;// OKS3是一个变量

}

另外，对与在结构中定义结构本身的变量也有几种写法

struct S6 {

S6* ptr;

};

// 这种写法只能在C++中使用

typedef struct {

S7* ptr;

} S7;

// 这是一种在C和C++中都是错误的定义

如果在C中，我们可以使用这样一个“曲线救国的方法“

typedef struct tagS8{

tagS8 * ptr;

} S8;

第三篇：struct和typedef struct

分三块来讲述：
1 首先：
在C中定义一个结构体类型要用typedef:
typedef struct Student
{
int a;
}Stu;
于是在声明变量的时候就可：Stu stu1;
如果没有typedef就必须用struct Student stu1;来声明
这里的Stu实际上就是struct Student的别名。
另外这里也可以不写Student（于是也不能struct Student stu1;了）
typedef struct
{
int a;
}Stu;
但在c++里很简单，直接
struct Student
{
int a;
};
于是就定义了结构体类型Student，声明变量时直接Student stu2；
===========================================
2其次：
在c++中如果用typedef的话，又会造成区别：
struct Student 
{ 
int a; 
}stu1;//stu1是一个变量 
typedef struct Student2 
{ 
int a; 
}stu2;//stu2是一个结构体类型 
使用时可以直接访问stu1.a
但是stu2则必须先 stu2 s2;
然后 s2.a=10;
===========================================
3 掌握上面两条就可以了，不过最后我们探讨个没多大关系的问题
如果在c程序中我们写：
typedef struct
{
int num;
int age;
}aaa,bbb,ccc;
这算什么呢？
我个人观察编译器（VC6）的理解，这相当于
typedef struct
{
int num;
int age;
}aaa；
typedef aaa bbb;
typedef aaa ccc;
也就是说aaa,bbb,ccc三者都是结构体类型。声明变量时用任何一个都可以,在c++中也是如此。但是你要注意的是这个在c++中如果写掉了typedef关键字，那么aaa，bbb，ccc将是截然不同的三个对象。

第四篇：C/C++中typedef struct和struct的用法

struct _x1 { ...}x1; 和 typedef struct _x2{ ...} x2; 有什么不同？ 

其实, 前者是定义了类_x1和_x1的对象实例x1, 后者是定义了类_x2和_x2的类别名x2 , 

所以它们在使用过程中是有取别的.请看实例1. 

[知识点] 

结构也是一种数据类型, 可以使用结构变量, 因此, 象其它 类型的变量一样, 在使用结构变量时要先对其定义。 

定义结构变量的一般格式为: 

struct 结构名 

{ 

类型 变量名; 

类型 变量名; 

... 

} 结构变量; 

结构名是结构的标识符不是变量名。 

另一种常用格式为: 

typedef struct 结构名 

{ 

类型 变量名; 

类型 变量名; 

... 

} 结构别名; 

另外注意: 在C中，struct不能包含函数。在C++中，对struct进行了扩展，可以包含函数。 

======================================================================

实例1: struct.cpp 

#include <iostream> 

using namespace std; 

typedef struct _point{ 

int x; 

int y; 

}point; //定义类，给类一个别名 

struct _hello{ 

int x,y; 

} hello; //同时定义类和对象 

int main() 

{ 

point pt1; 

pt1.x = 2; 

pt1.y = 5; 

cout<< "ptpt1.x=" << pt1.x << "pt.y=" <<pt1.y <<endl; 

//hello pt2; 

//pt2.x = 8; 

//pt2.y =10; 

//cout<<"pt2pt2.x="<< pt2.x <<"pt2.y="<<pt2.y <<endl; 

//上面的hello pt2;这一行编译将不能通过. 为什么? 

//因为hello是被定义了的对象实例了. 

//正确做法如下: 用hello.x和hello.y 

hello.x = 8; 

hello.y = 10; 

cout<< "hellohello.x=" << hello.x << "hello.y=" <<hello.y <<endl; 

return 0; 

}

第五篇：问答

Q：用struct和typedef struct 定义一个结构体有什么区别？为什么会有两种方式呢？

struct Student 
{ 
int a; 
} stu; 
typedef struct Student2 
{ 
int a; 
}stu2;

A：

事实上，这个东西是从C语言中遗留过来的，typedef可以定义新的复合类型或给现有类型起一个别名，在C语言中，如果你使用 
struct xxx 
{ 
}; 的方法，使用时就必须用 struct xxx var 来声明变量，而使用
typedef struct 
{ 
}的方法 就可以写为 xxx var; 
不过在C++中已经没有这回事了，无论你用哪一种写法都可以使用第二种方式声明变量，这个应该算是C语言的糟粕。






typedef 的用法
 
*****以下是参考部分*****
用途一：
定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。比如：
 
char* pa, pb;  // 这多数不符合我们的意图，它只声明了一个指向字符变量的指针，
 
// 和一个字符变量；
 
以下则可行：
 
typedef char* PCHAR;
 
PCHAR pa, pb;      
 
 
 
用途二：
用在旧的C代码中，帮助struct。以前的代码中，声明struct新对象时，必须要带上struct，即形式为： struct 结构名对象名，如：
struct tagPOINT1
 {
    int x; 
    int y; 
};
struct tagPOINT1 p1;
 
而在C++中，则可以直接写：结构名对象名，即：tagPOINT1 p1;
 
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是定义了一种类型的新别名，不是简单的字符串替换，所以它比宏来得稳健。
 
 
 
用途四：
 
为复杂的声明定义一个新的简单的别名。方法是：在原来的声明里逐步用别名替换一部分复杂声明，如此循环，把带变量名的部分留到最后替换，得到的就是原声明的最简化版。举例： 
 
 原声明：void (*b[10]) (void (*)());
 
变量名为b，先替换右边部分括号里的，pFunParam为别名一：
 
typedef void (*pFunParam)();
 
再替换左边的变量b，pFunx为别名二：
 
typedef void (*pFunx)(pFunParam);
 
原声明的最简化版：
 
pFunx b[10];
 
 
 
原声明：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。
 
*****以上为参考部分，以下为本人领悟部分*****
 
使用示例：
 
1.比较一：
 
#include <iostream>
using namespace std;
 
typedef int (*A) (char, char);
 
int ss(char a, char b)
{
    cout<<"功能1"<<endl;
    cout<<a<<endl;
    cout<<b<<endl;
    return 0;
}
 
int bb(char a, char b)
{
    cout<<"功能2"<<endl;
    cout<<b<<endl;
    cout<<a<<endl;
    return 0;
}
 
void main()
{
    A a;
    a = ss;
    a('a','b');
    a = bb;
    a('a', 'b');
}
 
2.比较二：
 
typedef int (A) (char, char);
 
void main()
{
    A *a;
    a = ss;
    a('a','b');
    a = bb;
    a('a','b');
}
 
两个程序的结果都一样：
功能1
a
b
功能2
b
a
 
 
*****以下是参考部分*****
typedef 与 #define的区别：
 
案例一：
 
通常讲，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++错误。






typedef的妙用与指针的使用法则
2008年11月03日 星期一 09:35
typedef给你一种方式来克服“*只适合于变量而不适合于类型”的弊端。你可以如下使用typedef：   
typedef char * PCHAR; 
PCHAR p,q;     
这里的p和q都被声明为指针。（如果不使用typedef，q将被声明为一个char变量，这跟我们的第一眼感觉不太一致！）下面有一些使用typedef的声明，并且给出了解释：     
typedef char *a;//a is a pointer to a char     
typedef a b();//b is a function that returns a pointer to a char     
typedef b *c;//c is a pointer to a function that returns a pointer to a char     
typedef c d();//d is a function returning a pointer to a function that returns a pointer to a char    
typedef d *e;//e is a pointer to a function returning a pointer to a function that returns a pointer to a char       e var[10];//var is an array of 10 pointers to functions returning ppointers to functions returning pointers to chars.      
typedef经常用在一个结构声明之前，如下。这样，当创建结构变量的时候，允许你不使用关键字struct（在C中，创建结构变量时要求使用struct关键字，如struct   tagPOINT   a；而在C++中，

struct可以忽略，如tagPOINT   b）。 
typedef struct tagPOINT 
{ 
          int x; 
          int y; 
}POINT; 
   POINT p; /* Valid C code */     
函数指针 
   
函数指针可能是最容易引起理解上的困惑的声明。函数指针在DOS时代写TSR程序时用得最多；在Win32和X-Windows时代，他们被用在需要回调函数的场合。当然，还有其它很多地方需要用到函数指针：虚函数表，STL中的一些模板，Win   NT/2K/XP系统服务等。让我们来看一个函数指针的简单例子：     
int (*p)(char);     
这里p被声明为一个函数指针，这个函数带一个char类型的参数，并且有一个int类型的返回值。另外，带有两个float类型参数、返回值是char类型的指针的指针的函数指针可以声明如下：     
char ** (*p)(float,float);     
那么，带两个char类型的const指针参数、无返回值的函数指针又该如何声明呢？参考如下：     
void * (*a[5])(char *const,char *const);     
“右左法则”[重要！！！]     
The right-left rule:Start reading the declaration from the innermost parentheses,go right,and then go left.When you encounter parentheses,the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole   declaration has been parsed.     
这是一个简单的法则，但能让你准确理解所有的声明。这个法则运用如下：从最内部的括号开始阅读声明，向右看，然后向左看。当你碰到一个括号时就调转阅读的方向。括号内的所有内容都分析完毕就跳出括号的范围。这样继续，直到整个声明都被分析完毕。     
对上述“右左法则”做一个小小的修正：当你第一次开始阅读声明的时候，你必须从变量名开始，而不是从最内部的括号。     
下面结合例子来演示一下“右左法则”的使用。     
int * (* (*fp1) (int) ) [10];     
阅读步骤： 
1.   从变量名开始   ---------------------------- fp1 
2.   往右看，是“)”，因此往左看，是“*”   -------   一个指针 
3.   跳出括号，碰到了(int)   ------------ 一个带一个int参数的函数 
4.   向左看，发现一个*   ---------------------（函数）返回一个指针 
5.   跳出括号，向右看，碰到[10]   -------------   一个10元素的数组 
6.   向左看，发现一个*   -----------------------   指针 
7.   向左看，发现int   -----------------------   int类型 
   
总结：fp1被声明成为一个函数的指针的指针的数组，这个数组有10个元素，函数的原型为带一个int类型的参数，返回值为一个指针？     
再来看一个例子：     
int *( *( *arr[5])())();     
阅读步骤： 
1.   从变量名开始   ----------------------------------   arr 
2.   往右看，发现是一个数组   -------------------- 一个5元素的数组 
3.   向左看，发现一个*   ------------------------------   指针 
4.   跳出括号，向右看，发现()   ------------------   不带参数的函数 
5.   向左看，碰到*   ---------------------   （函数）返回一个指针 
6.   跳出括号，向右发现()   --------------------- 不带参数的函数 
7.   向左，发现*   -------------------------   （函数）返回一个指针 
8.   继续向左，发现int   -----------------------------   int类型         
还有更多的例子：     
float（ * ( *b())[])(); //b is a function that returns a pointer to   an array of pointers to functions returning floats.     
void * ( *c) ( char, int(*)()); //c is a pointer to a function that   takes two parameters:a char and a pointer to a function   that takes   no parameters and returns an int and returns a pointer to void.     
void ** (*d) (int &,char **(*)(char *,char **));//d is a pointer to   a function that takes two parameters: a reference to an int and a pointer to a function that takes two parameters:a pointer to a char and a pointer to a pointer to a char and returns a pointer to a pointer to a char and returns a pointer to a pointer to void     

float ( * ( * e[10]) (int &)[5]; // e is an array of 10 pointers to 
functions that take a single reference to an int as an argument and   return pointers to anarray of 5 floats





typedef和#define的用法与区别
一、typedef的用法

在C/C++语言中，typedef常用来定义一个标识符及关键字的别名，它是语言编译过程的一部分，但它并不实际分配内存空间，实例像：

typedef    int       INT;
typedef    int       ARRAY[10];
typedef   (int*)   pINT;

typedef可以增强程序的可读性，以及标识符的灵活性，但它也有“非直观性”等缺点。

二、#define的用法

#define为一宏定义语句，通常用它来定义常量(包括无参量与带参量)，以及用来实现那些“表面似和善、背后一长串”的宏，它本身并不在编

译过程中进行，而是在这之前(预处理过程)就已经完成了，但也因此难以发现潜在的错误及其它代码维护问题，它的实例像：

#define   INT             int
#define   TRUE         1
#define   Add(a,b)     ((a)+(b));
#define   Loop_10    for (int i=0; i<10; i++)

在Scott Meyer的Effective C++一书的条款1中有关于#define语句弊端的分析，以及好的替代方法，大家可参看。

三、typedef与#define的区别

从以上的概念便也能基本清楚，typedef只是为了增加可读性而为标识符另起的新名称(仅仅只是个别名)，而#define原本在C中是为了定义常量

，到了C++，const、enum、inline的出现使它也渐渐成为了起别名的工具。有时很容易搞不清楚与typedef两者到底该用哪个好，如#define

INT int这样的语句，用typedef一样可以完成，用哪个好呢？我主张用typedef，因为在早期的许多C编译器中这条语句是非法的，只是现今的

编译器又做了扩充。为了尽可能地兼容，一般都遵循#define定义“可读”的常量以及一些宏语句的任务，而typedef则常用来定义关键字、冗

长的类型的别名。

宏定义只是简单的字符串代换(原地扩展)，而typedef则不是原地扩展，它的新名字具有一定的封装性，以致于新命名的标识符具有更易定义变

量的功能。请看上面第一大点代码的第三行：

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

效果相同？实则不同！实践中见差别：pINT a,b;的效果同int *a; int *b;表示定义了两个整型指针变量。而pINT2 a,b;的效果同int *a, b;

表示定义了一个整型指针变量a和整型变量b








typedef用法小结
来源一:Using typedef to Curb Miscreant Code

      Typedef 声明有助于创建平台无关类型，甚至能隐藏复杂和难以理解的语法。不管怎样，使用 typedef 能为代码带来意想不到的好处，通过本文你可以学习用 typedef 避免缺欠，从而使代码更健壮。
      typedef 声明，简称 typedef，为现有类型创建一个新的名字。比如人们常常使用 typedef 来编写更美观和可读的代码。所谓美观，意指 typedef 能隐藏笨拙的语法构造以及平台相关的数据类型，从而增强可移植性和以及未来的可维护性。本文下面将竭尽全力来揭示 typedef 强大功能以及如何避免一些常见的陷阱。
      如何创建平台无关的数据类型，隐藏笨拙且难以理解的语法? 
 
使用 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>>。

 作者简介
　　Danny Kalev 是一名通过认证的系统分析师，专攻 C++ 和形式语言理论的软件工程师。1997 年到 2000 年期间，他是 C++ 标准委员会成员。最近他以优异成绩完成了他在普通语言学研究方面的硕士论文。 业余时间他喜欢听古典音乐，阅读维多利亚时期的文学作品，研究 Hittite、Basque 和 Irish Gaelic 这样的自然语言。其它兴趣包括考古和地理。Danny 时常到一些 C++ 论坛并定期为不同的 C++ 网站和杂志撰写文章。他还在教育机构讲授程序设计语言和应用语言课程。

来源二：(http://www.ccfans.net/bbs/dispbbs.asp?boardid=30&id=4455)
 C语言中typedef用法
1. 基本解释

　　typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。

　　在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。

　　至于typedef有什么微妙之处，请你接着看下面对几个问题的具体阐述。
　2. typedef & 结构的问题

　　当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？莫非C语言不允许在结构中包含指向它自己的指针吗？请你先猜想一下，然后看下文说明：

typedef struct tagNode
{
　char *pItem;
　pNode pNext;
} *pNode;
　　答案与分析：

　　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来定义变量。
　　答案与分析
　　C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。
　　根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。

　　解决这个问题的方法有多种：

　　1)、

typedef struct tagNode 
{
　char *pItem;
　struct tagNode *pNext;
} *pNode;

　　2)、

typedef struct tagNode *pNode;
struct tagNode 
{
　char *pItem;
　pNode pNext;
};
　　注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。

　　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用法例子：

#define f(x) x*x
main( )
{
　int a=6，b=2，c；
　c=f(a) / f(b)；
　printf("%d 
"，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. doube(*)() (*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. doube(*)() (*pa)[9]; 
//首先为上面表达式蓝色部分声明一个新类型
typedef double(*pFun)();
//整体声明一个新类型
typedef pFun (*pFunParam)[9];
//使用定义的新类型来声明对象，等价于doube(*)() (*pa)[9];
pFunParam pa;





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

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

 如何创建平台无关的数据类型，隐藏笨拙且难以理解的语法? 
 
 使用 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>>。

 作者简介
　　Danny Kalev 是一名通过认证的系统分析师，专攻 C++ 和形式语言理论的软件工程师。1997 年到 2000 年期间，他是 C++ 标准委员会成员。最近他以优异成绩完成了他在普通语言学研究方面的硕士论文。 业余时间他喜欢听古典音乐，阅读维多利亚时期的文学作品，研究 Hittite、Basque 和 Irish Gaelic 这样的自然语言。其它兴趣包括考古和地理。Danny 时常到一些 C++ 论坛并定期为不同的 C++ 网站和杂志撰写文章。他还在教育机构讲授程序设计语言和应用语言课程。

 
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;   //不可行 
编译将失败，会提示“指定了一个以上的存储类”。

1 Typedef 与基本数据类型
typedef 声明，简称 typedef，为现有数据类型创建一个新的名字。比如人们常常使用
typedef 来编写更美观和可读的代码。使用 typedef 为现有类型创建同义字。定义易于记忆
的类型名。
typedef 使用最多的地方是创建易于记忆的类型名，用它来归档程序员的意图。类型出
现在所声明的变量名字中，位于 ''typedef'' 关键字右边。例如：
typedef int size;
此声明定义了一个 int 的同义字，名字为 size。注意 typedef 并不创建新的类型。它
仅仅为现有类型添加一个同义字。你可以在任何需要 int 的上下文中使用 size：
void measure(size * psz);
size array[4];
size len = file.getlength();
std::vector 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);
用GNU 的gcc 和g++编译器，是会出现警告的，按照顺序，‘const pstr'被解释为‘const
char* ‘（一个指向 char 的常量指针），而不是‘char *'（指向char 的指针）。这个问题很容易
解决：
typedef const cpstr;
int mystrcmp(cpstr, cpstr); //
现在是正确的。
记住：不管什么时候，只要为指针声明 typedef，那么都要在最终的 typedef 名称中加
一个 const，以使得该指针本身是常量，而不是对象。
2 Typedef 与结构体
2.1 首先：
在C 中定义一个结构体类型要用typedef:
typedef struct Student
{
int a;
}Stu;
于是在声明变量的时候就可以直接这样定义：Stu stu1;
如果没有typedef 就必须用struct Student stu1;来声明变量stu1。
这里的Stu 实际上就是struct Student 的别名。
另外这里也可以不写Student，
typedef struct
{
int a;
}Stu;
但是也就不能这样定义了：struct Student stu1;
而只能这样定义：Stu stu1;
2.2 其次：
在c++中如果用typedef 的话，又会造成区别：
struct Student
{
int a;
}stu1;//stu1 是一个变量
typedef struct Student2
{
int a;
}stu2;//stu2 是一个结构体类型
使用时可以直接访问stu1.a
但是stu2 则必须先 stu2 s2;
然后 s2.a=10;
因为C 和C++中对struct 的应用是不同的。
2.3 其他
掌握上面两条就可以了，不过最后我们探讨个没多大关系的问题
如果在c 程序中我们写：
typedef struct
{
int num;
int age;
}aaa,bbb,ccc;
这算什么呢？
我个人观察编译器（VC6）的理解，这相当于
typedef struct
{
int num;
int age;
}aaa；
typedef aaa bbb;
typedef aaa ccc;
也就是说aaa,bbb,ccc 三者都是结构体类型。声明变量时用任何一个都可以,在c++中也
是如此。但是你要注意的是这个在c++中如果写掉了typedef 关键字，那么aaa，bbb，ccc
将是截然不同的三个对象。
3 Typedef 与enum
typedef enum 表示定义了一个枚举型的数据结构。
比如你用下面的方式进行定义:
typedef enum
{ DWI_Nothing,
DWI_2x2Icon,
DWI_Icon,
DWI_Text,
DWI_FullText,
DWI_CenterText,
DWI_FullCenterText,
DWI_None
} DrawMenuItemType;
你可以用上边的DrawMenuItemType 去定义变量，
例如：DrawMenuItemType Data1
Data1 这个变量的取值就是
DWI_Nothing,
DWI_2x2Icon,
DWI_Icon,
DWI_Text,
DWI_FullText,
DWI_CenterText,
DWI_FullCenterText,
DWI_None
中的一个，这些你都可以自己取值。如果你不赋值的话，默认第一个取值为零，其后面
的依次加1。如果你给DWI_Nothing 取值为m，相应的它后面的没有显示赋值的就要在这
个基础上依次加1，直到遇到显示赋值的为止。DWI_2x2Icon 的值为m+1；DWI_Icon 的值
为m+2.
4 Typedef 与函数指针
4.1 简单的函数指针的应用。
//形式1：返回类型(*函数名)(参数表)
char (*pFun)( int );
char glFun( int a )
{
return 4;
}
void main()
{
pFun = glFun;
(*pFun)(2);
}
第一行定义了一个指针变量pFun。首先我们根据前面提到的“形式1”认识到它是一个指
向某种函数的指针，这种函数参数是一个int 型，返回值是char 类型。只有第一句我们还无
法使用这个指针，因为我们还未对它进行赋值。
第二行定义了一个函数glFun()。该函数正好是一个以int 为参数返回char 的函数。我们
要从指针的层次上理解函数——函数的函数名实际上就是一个指针，函数名指向该函数的代
码在内存中的首地址
然后就是main()函数了，它的第一句您应该看得懂了——它将函数glFun 的地址赋值给
变量pFun。main()函数的第二句中*pFun 显然是取pFun 所指向地址的内容，当然也就是取
出了函数glFun()的内容，然后给定参数为2。
4.2 使用typedef
//形式2：typedef 返回类型(*新类型)(参数表)
typedef char (*PTRFUN)(int);
PTRFUN pFun;
char glFun(int a)
{
Return 4;
}
void main()
{
pFun = glFun;
(*pFun)(2);
}
typedef 的功能是定义新的类型。第一句就是定义了一种PTRFUN 的类型，并定义这种
类型为指向某种函数的指针，这种函数以一个int 为参数并返回char 类型。后面就可以像使
用int,char 一样使用PTRFUN 了。
第二行的代码便使用这个新类型定义了变量pFun，此时就可以像使用形式1 一样使用
这个变量了。
5 Typedef 与#define
5.1#define 用法
#define 是预处理指令，在编译预处理时进行简单的替换，不作正确性检查，不关含义
是否正确照样带入，只有在编译已被展开的源程序时才会发现可能的错误并报错。例如：
#define PI 3.1415926
程序中的：area=PI*r*r 会替换为3.1415926*r*r
如果你把#define 语句中的数字9 写成字母g 预处理也照样带入。
5.2 typedef 与#define 的区别
typedef 是在编译时处理的。它在自己的作用域内给一个已经存在的类型一个别名。
typedef int * int_ptr;
#define int_ptr int *
作用都是用int_ptr 代表 int * ,但是二者不同，正如前面所说 ，#define 在预处理 时进
行简单的替换，而typedef 不是简单替换 ，而是采用如同定义变量的方法那样来声明一种类
型。也就是说;
#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 所指的对象。
注： #define 不是语句 不要在行末加分号，否则 会连分号
一块置换。