typedef 与指针

typedef 与指针zz
---------------------------------------------
指向数组的指针（叫做数组指针）
指向函数的指针，即函数指针
int *f（int ），f 函数，返回int 型的指针
int （*f）（），f 是指向int（int）的指针，f 是一个函数指针变量
：函数名是一个地址。
一个函数在编译时被分配一个入口地址，将这个入口地址称为函数的指针，可
---------------------------------------------------------------------
-----
typedef 似乎很简单，如typedef int integer；然而，这些简单的typedef 语
句容易让人产生一种误解，typedef 就是一种宏替换,把后面的自定义类型替换
成前面的已知类型，事实是这样的吗?显然不是！
考虑这样的问题：如何定义一个指向整型的指针类型？如何定义一个函数指
针类型？
第一个问题很简单：typedef int* int_pointer;即可，对于第二个问题，似
乎就没有那么简单了，首先，看函数指针的定义方法：int (*p)(const&, int);
这个p 指向的函数必须返回int，形参必须是const&和int。现在要将这种指针
类型命名为func_pointer，其定义的方法如下：
typedef int (*func_pointer)(const&, int);
可以这样来理解:typedef int integer;将typedef 去掉，那就是个变量的定
义，这儿即定义了一个int 型的变量integer，考虑这个integer 是什么类型的，
那么这个typedef 语句就是将integer 定义为这个类型的。将typedef int
(*func_pointer)(const&, int);中的typedef 去掉，就成了一个函数指针定义，
即func_pointer 被定义为函数指针类型变量，那么原来的typedef 即将
func_pointer 定义为函数指针类型。
----
typedef int (*func_pointer)(const&, int);
typedef 是一种存储类型的声明。
函数指针类型，是一种类型，int (*)(const&, int);就是函数指针类型，
func_pointer 是函数指针类型的变量，是一个变量的名字。
------
int (*testCases[10])();
这个表达式是什么意思？-------------函数指针数组
----
函数指针类型。int（*）（）
变量名是testCases【10】，是一个函数指针类型的变量，----函数指针类型的
数组
指数组testCase，大小是10，其各个元素都是函数指针类型的。
等价于：
typedef 来简化这种定义：
typedef int (*PFV)();
PFV testCases[10];
===
数组指针(即指向数组的指针)的定义: int (*ptr)[3];
这个表达式定义了一个数组指针ptr，ptr 一次跨越一个由3 个int 型组成
的一维数组。发现其定义的方式与函数指针定义的方式很相似，只是把()换作
了[]。
-----
----
指针，数组，函数糅合在了一起问题变得复杂起来。它定义了数组，
testCases[10],数组中的元素是函数指针，函数指针的类型是int (*)();
怎么来理解这种定义呢？首先考虑数组的定义，数组的定义一般模式是：类
型数组名[大小];
考虑这个表达式，似乎是定义了一个数组，但是数组名[大小]被夹在了中间，那
么类型是什么呢，发现类型并不是简单的数据类型，而是一个函数指针类型int
(*p)()，这个函数没有参数，返回int 型。从而这个表达式的含义是：定义了一
个函数指针型的数组，大小是10。可以利用typedef 来简化这种定义：
typedef int (*PFV)();
PFV testCases[10];
其实int (*testCases[10])();这儿我们定义了一个函数指针数组，数组是主体。
下面考虑这样的问题：如何定义一个指向数组的指针（叫做数组指针）？
指向数组的指针，好像比较新鲜，所谓指向数组的指针，即指针的一步跨越
是一个数组，跟指向整型的指针一步跨越一个整型一个道理。事实上前面已经碰
到了指向数组的指针，如二维数组名，实际上就是一个指向数组的指针，它一次
跨越一行的数据，实际上即是跨越了一个一维数组，而三维数组名呢，也是一个
指向数组的指针，它一次跨越的是低维组成的一个二维数组。
数组指针(即指向数组的指针)的定义: int (*ptr)[3];
这个表达式定义了一个数组指针ptr，ptr 一次跨越一个由3 个int 型组成
的一维数组。发现其定义的方式与函数指针定义的方式很相似，只是把()换作
了[]。更进一步，如果要定义一个指向数组的指针，而数组中的元素不是简单的
int 型，而是比较复杂的类型，那该如何定义呢？事实上数组指针这种东西就已
经够稀有的了，一般编程绝对不会用到，我们只需要能读懂一些比较复杂的东西
就行了，自己没有必要构造这么复杂的类型。
比较复杂的表达式：
1、int (*(*(*p())[])())[];
首先，根据p()判断p 是一个函数，再根据p()前面的*号判断该函数返回一
个指针，下面就看这个指针指向的是什么类新了，我们可以把*p()替换成一个
*pointer，这个pointer 就是函数p 返回的指针，那么就成了int
(*(*(*pointer)[])())[];再根据(*pointer)[]，这说明了指针pointer 是指向
的一个数组，那么这个数组中的元素是什么类型呢？由于数组名实际上就是个指
针，我们把(*pointer)[]（即(*p())[]）替换成一个array，这样就成了int
(*(*array)())[];发现array 是一个函数指针，从而数组中的每个元素是函数指
针，而这个函数呢，又返回一个指针类型，把(*array)()用func 代替，就成了
int (*func)[];这说明了func 函数返回的是指向数组的指针，数组中的元素是
int 型。
这个表达式够酷!!!
2、p = (int( * (*)[20])[10])q;
这是一个强制类型转换，q 被强制类型转换成一个这样的指针类型，这个指
针呢直线一个具有20 个元素的数组，这个数组中的元素也是指针，是指向另外
一种数组，这种数组是含有10 个int 型数据的一维数组。
可见，分析复杂的表达式时（所谓复杂，即糅合了指针，数组，函数三样，
缺少了一样就不会复杂了），从括号的最里层做起，最里层的东西是复杂表达式
的“根节点”，然后一层一层脱，脱的时候，是这样的，比如里层是个数组，那
么就是说这个数组的元素是什么呢，那就是外层的东西，如果里层是个有返回值
的函数，那么就是说这个函数返回什么值呢？那就是外层的东西，就这样一层一
层地把表达式解析清楚。
关于typedef 还有一些要说的：
typedef int (*PFV)(); 这是定义了一个函数指针，那么PFV p；就可以定义了
一个指向函数的指针。
typedef int (*p[10])(); 这是把p 定义为函数指针数组，那么p array;语句
就可以定义了一个函数指针数组，数组名即为array，array 这个数组含10 个元
素。
typedef int (*parray)[3];这是定义了一个指向整型数组的指针，那么parray
ptr；就定义了一个指向数组的指针。如何对这个ptr 赋值或者初始化呢？事实
上，是通过二维数组名来对其进行赋值（初始化）的，因为二维数组名作为指针
来讲，就是一个指向数组的指针，一次跨越一个数组。
typedef int a[3][3]; 这个语句什么意思呢？这是把a 定义为一个3*3 的整型
数组类型。当a b = {1}时就完成了一个3×3 的整型数组的定义初始化的工作。
同样，简单一点typedef int a[3];这个语句是把a 定义为一个一维数组类型。
typedef void func(int); 这个语句定义了一个函数类型。通过这个typedef，
我们可以比较清晰地定义出函数指针，func* p；即可。（p 是void（int）类
型指针）
typedef char* string;
const string str;
这个str 是什么类型的呢？const char * str，即指向常量的指针类型？事实上，
答案有些不可思议，str 是一个常量指针，而不是指针常量，即const 修饰符针
对的是指针（就是str，string 是一个指针类型，指向char 类型变量），而不
是char。
以用一个指针变量指向该函数指针，然后通过该变量来调用函数。