typedef和define

第一：typedef的用途：
用途一：
在C中定义一个结构体类型要用typedef:
　typedef struct Student
　{
　　int a;
　}Stu;
于是在声明变量的时候就可：Stu stu1;(如果没有typedef就必须用struct Student stu1;)
这里的Stu实际上就是struct Student的别名。Stu等价于struct Student另外这里也可以不写Student
　typedef struct
　　{
　　int a;
　　}Stu;
（于是也不能struct Student stu1;了，必须是Stu stu1;
但在c++里很简单，直接
　struct Student
　{
　　int a;
　};　　　　
　　于是就定义了结构体类型Student，声明变量时直接Student stu2； 这样就比原来的方式少写了一个struct，比较省事，尤其在大量使用的时候。

用途二：（定义方便记忆型的类型名）
定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。
比如：char* pa, pb; 
// 这多数不符合我们的意图，它只声明了一个指向字符变量的指针，
// 和一个字符变量；
以下则可行：
typedef char* PCHAR;
PCHAR pa, pb;  
这种用法很有用，特别是char* pa, pb的定义，初学者往往认为是定义了两个字符型指针，其实不是，而用typedef char* PCHAR就不会出现这样的问题，减少了错误的发生。

用途三：（适用于跨平台开发）
用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 (*)[]数组指针
实例：
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 和存储类关键字（storage class specifier）
        这种说法是不是有点令人惊讶，typedef 就像 auto，extern，mutable，static，和 register 一样，是一个存储类关键字。这并是说 typedef 会真正影响对象的存储特性；它只是说在语句构成上，typedef 声明看起来象 static，extern 等类型的变量声明。下面将带到第二个陷阱：
                  typedef register int FAST_COUNTER; // 错误
       编译通不过。问题出在你不能在声明中有多个存储类关键字。因为符号 typedef 已经占据了存储类关键字的位置，在 typedef 声明中不能用 register（或任何其它存储类关键字）。

参考：

http://www.cnblogs.com/charley_yang/archive/2010/12/15/1907384.html

http://www.cnblogs.com/csyisong/archive/2009/01/09/1372363.html