见怪不怪的typedef

typedef是C++中的一个十分重要的关键字，它有强大的功能和方法的用途。但是有时候，碰到一些用到typedef的地方却感到很奇怪了。

给个栗子尝尝：

typedef void(*pFun)(void);

很奇怪，你不觉得奇怪吗？反正我是信了，一个字-“怪”。

好，下面就讲一下C++中的一怪“typedef”。

typedef的定义是，为现有类型创建一个新的名字，或称为类型别名。这就是一个关键的突破点，无论typedef怎么应用，都不会脱离它本身的定义。

1、typedef定义一种类型的别名

typedef int* PINT;
PINT pa,pb;//pa和pb都是int*类型的指针

给一种类型进行重定义别名，可以方便我们使用。

2、typedef和struct

在旧的C代码中，struct定义一个结构体时，必须加上struct

typedef struct Point{
    int x;
    int y;
}Point;

3、typedef与平台无关性

用typedef来定义与平台无关的类型。比如定义一个叫 REAL 的浮点类型，在目标平台一上，让它表示最高精度的类型为：typedef long double REAL;

在不支持 long double 的平台二上，改为：typedef double REAL;

在连 double 都不支持的平台三上，改为：typedef float REAL;

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

4、typedef定义函数指针

首先说明一下函数型指针，我们知道每种类型对应着属于自身类型的指针，当然函数也不例外。当一个函数被执行时，在程序空间中占据一定空间，这个空间的起始地址是用函数名来表示的，称为函数的入口地址。也可以用指针指向这个入口地址，并通过该指针变量来调用这个函数。这种指针变量称为函数型指针变量，其一般形式为：

数据类型标识符 (*指针变量名) () ; 例如：void (*f)( );

上式定义了指针f, f指向的函数返回void类型类数据。注意其中(*f)中的括弧不可缺少，标识f是先与*结合，是指针变量，然后再与后面的()结合，表示此指针指向函数。

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

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 (*)[]数组指针

5、通过成员指针调用成员函数

可以在不必知道函数名的情况下，通过成员指针调用对象的成员函数。例如，函数dispatcher有一个变量pmf，通过它调用类成员函数，不管它调用的是strcpy()函数还是strcat()函数。指向外部原函数的指针和指向类成员函数的指针是有很大区别的。后者必须指向被调函数的宿主对象。因此，除了要有成员指针外，还要有合法对象或对象指针。

现举例做进一步说明。假设A有二个实例，成员函数指针支持多态性。这样在成员指针调用虚成员函数时是动态处理的(即所谓后联编 - 译注)。注意，不可调用构造和析构函数。示例如下：

A a1, a2;
A *p= &a1; //创建指向A的指针
//创建指向成员的指针并初始化
void (A::*pmf)(char *, const char *) = &A::strcpy;
//要将成员函数绑定到pmf，必须定义呼叫的对象。
//可以用*号引导：
void dispatcher(A a, void (A::*pmf)(char *, const char *))
{
　char str[];
　(a.*pmf)(str, “abc”); //将成员函数绑定到pmf
}
//或用A的指针表达方式指向成员指针：
void dispatcher(A * p, void (A::*pmf)(char *, const char *))
{
　char str[]; (p->*pmf)(str, “abc”);
}
//函数的调用方法为：
dispatcher(a, pmf); // .* 方式
dispatcher(&a, pmf); // ->* 方式 

6、高级使用技巧

以上是成员函数的基本知识。现在介绍它的高级使用技巧。 
6.1 成员指针数组

在下例，声明了一个含有二个成员指针的数组，并分配类的成员函数地址给成员指针

PMA pmf[]= {&A::strcpy, &A::strcat}; 

等同于

void (A::*PMA[])(char *, const char *)= {&A::strcpy, &A::strcat}; 

这样的数组在菜单驱动应用中很有用。选择菜单项后，应用将调用相应的回调函数，如下所示：

enum MENU_OPTIONS { COPY, CONCAT };
int main()
{
　MENU_OPTIONS option; char str[];
　//从外部资源读取选项
　switch (option)
　{
     case COPY:
　    (pa->*pmf[COPY])(str, “abc”);
　    break;
     case CONCAT:
　    (pa->*pmf[CONCAT])(str, “abc”);
　    break;
　}
} 

6.2 void类型的指针

void含义：

void是“无类型”，void*则为无类型指针，void*可以指向任何类型的数据。

void a；//此变量没有任何实际意义，无法编译通过“illegal use of type”

void 的作用：

1、对程序返回的限定

2、对函数参数的限定

我们知道，如何指针p1和p2的类型相同，那么我们可以直接在p1和p2间赋值，如果不同，必须使用强制类型转换。

如：float *p1; int *p2;

若：p1 = p2; 编译出错：“can not covert from int* to float*”

必须为：p1 = (float*)p2;

而void*不同，任何类型的指针都可以直接赋为它，不需要强制类型转换：

如：void *p1; int *p2;

可作：p1 =p2;

无类型可以包容有类型，有类型不能包容无类型：

必须为：p2 = (int*)p1;

如果函数的参数可以是任意类型指针，那么应声明其参数为void *

典型的如内存操作函数memcpy和memset的函数原型分别为：

void* memcpy(void *dest, const void *src, size_t len);
void* memset(void *buffer,int c, size_t num);

这样，任何类型的指针都可以传入memcpy和memset中，这也真实地体现了内存操作函数的意义，因为它操作的对象仅仅是一片内存，而不论内存是什类型。

7、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[] = "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++错误。