解读复杂的类型声明

2.解读类型声明的核心法则
其实核心法则只有一条：首先找到被声明的标识符，然后按先右后左的顺序依次与类型说明符结合。如果有括号，那就优先与括号里的结合。是的，就这么简单。无论看起来多么复杂的类型声明，都可以按这条法则逐一拆分。接下来不妨用几个简单的例子来说明
int *a[10];
a是数组，还是指针？根据核心法则，a应该先与右侧的[10]结合，解读成a[10]，因此a是一个有10个元素的数组。然后再与左侧的int*结合，a是一个有10个int*元素的指针数组。
int (*a)[10];
这个呢？由于有括号，a必须先和括号里的*结合，解读成*a，因此a是一个指针。然后与右侧的[10]结合，表示a是一个指针，指向有10个元素的数组。最后与左侧的int结合，表示数组的每个元素都是int类型。因此a是一个指向int[10]数组的数组指针。
int *a[2][3];
a先与右侧的[2]和[3]结合，表示a是一个[2][3]的二维数组。然后与左侧的int *结合，表示数组的每个元素都是int*指针。
int (*a[2])[3];
a先与右侧的[2]结合，表示a是一个有2个元素的数组。然后与左侧的*结合，表示每个元素都是指针类型。接下来括号整体与右侧的[3]、左侧的int结合，表示数组中的指针指向一个int[3]数组。因此，a是一个有2个元素的数组，每个元素都是一个指向int[3]的数组指针。可以这样初始化a中的元素：
int b1[3] = {1,2,3};
int b2[3] = {4,5,6};
int (*a[2])[3] = {&b1, &b2};

3.更复杂的类型声明
接下来我们引入函数和函数指针，并使用核心法则来逐一解读一些更复杂的类型声明，看看它们到底是什么东西。
double (*(*fp)[3])(double);
首先找到被声明的标识符fp，由于有括号，fp先与*结合，表示fp是一个指针。然后与右侧的[3]结合成(*fp)[3]，表示fp是一个数组指针，指向有3个元素的数组。接下来与左侧的*结合成*(*fp)[3]，表示数组中的每个元素也是指针。接下来与右侧的(double)结合，出现在右侧的括号()是函数的参数列表，double表示第一个参数类型为double。因此数组中的每个元素是函数指针，指向一个参数列表为(double)的函数。最后与左侧的double结合，表示函数的返回值类型是double。总结一下：fp是一个数组指针，指向有3个元素的数组，数组中的每个元素都是指向原型为double f(double)函数的函数指针。
尝试一下初始化fp。可以用math.h中的三个函数sin()、cos()、tan()构成一个数组，然后令fp指向它。
#include <math.h>
int main()
{
double (*a[3])(double) = {sin, cos, tan};
double (*(*fp)[3])(double) = &a;
printf("%f", (*fp)[0](3.14)); // 调用sin(3.14)
}
注意函数sin、cos、tan可以直接赋值给函数指针，无需再取地址。（C++中的成员函数规则不同，不过这里只讨论C语言）

再举一个例子
void (*signal(int, void(*)(int)))(int);
注意signal和*并没有用括号括在一起，所以根据核心法则，signal应该先与右侧的(int, void(*)(int))结合。这是函数的参数列表，第一个参数是int，第二个参数是void(*)(int)，这是一个函数指针，指向原型为void f(int)的函数。如果不理解的话，可以人为加上一个名字再看：void(*fp)(int)。因此signal是一个函数，它有两个参数，第一个参数是int，第二个参数是函数指针。
接下来与signal左侧的*结合，表示函数signal的返回值是一个指针。然后括号中的整体与右侧的(int)结合，表示指针指向一个参数列表为(int)的函数。最后与左侧的void结合，表示指针指向的函数的返回值为void。在解读函数signal的返回值类型时，你也可以把已经结合的部分signal(int, void(*)(int))直接划掉，那么声明就只剩下了void (*)(int)，这就是signal函数的返回值类型了，是不是一下子就好辨认了呢？
signal函数是一个真实的例子。它是一个POSIX API，用于注册信号处理函数，以便在进程接收到相应信号时回调，学过Linux编程的同学应该很熟悉。不过，这个函数出于一些原因不建议使用，应该用sigaction()代替。

3.cv qualifier
cv指的是const和volatile修饰符。这两个修饰符的语法规则完全相同，不过后者很少使用而前者很常见，因此下面就以const代替。
首先看整数类型、浮点类型等基础类型。这个很简单，const表示对象不可修改。
const int n = 100; // 变量n被初始化为100且不可修改
n = 99; // 编译错误
这样的const称为顶层const。
接下来看指针类型，指针类型稍微复杂一点。对于int *p，它有两个地方可以加const，分别是*的前面和*的后面，分别称为底层const和顶层const。
const int *p; // 底层const
int * const p; // 顶层const
const int * const p; // 底层const+顶层const
底层const表示指针引用的对象值不可修改，而顶层const表示指针本身（的指向）不可修改。
int n = 100, m = 99;
const int *p = &n;
*p = 99; // 编译错误，指针引用的对象值不可修改
p = &m; // OK
n = 100; // OK，n本身并不是const
int * const p = &n;
*p = 99; // OK
p = &m; // 编译错误，指针的指向不可修改
可以按从右往左的顺序解读：
const int *p读作p是一个指针，指向一个const int。
int * const p读作p是一个const指针，指向一个int。
const int * const p读作p是一个const指针，指向一个const int。
int和const的顺序无关紧要，const int *p和int const *p是相同的语义。
在值传递时，顶层const会自动脱落，而底层const不会。
void foo(char *p, int n);
const char *s = "hello world";
const int i = 100;
foo(s, i); // s是底层const，赋值给char *p会导致底层const脱落，这是不允许的，编译器可能会报类似discards const qualifier的警告。而i是顶层const，赋值给int n是合法的，顶层const会自动脱落。

4.typedef
typedef用于定义新类型，它的语法和声明函数/变量完全相同，因此任何声明前面只要加个typedef就成了对应的类型定义。
int a; // 声明变量a（同时也是定义），a是一个int类型的变量
typedef int a; // 定义类型a，a就是int类型的别名
a aa; // 等价于int aa;
struct list {int x; struct list *next; } l; // 定义struct list类型的变量l
typedef struct list {int x; struct list *next; } l; // 定义struct list类型的别名l
l ll; // 等价于struct list ll;
char (*p)[10]; // 定义数组指针变量p，指向char[10]数组
typedef char (*p)[10]; // 定义数组指针类型char(*)[10]的别名p
p pp; // 等价于char (*pp)[10];
void (*handler)(int); // 定义函数指针变量handler，指向原型为void f(int)的函数
typedef (*sighandler_t)(int); // 定义函数指针类型void(*)(int)的别名sighandler_t
sighandler_t handler; // 等价于void (*handler)(int);
再回头看楼上的signal函数的声明void (*signal(int, void(*)(int)))(int);，我们发现它的第二个参数类型和返回值类型是相同的，都是函数指针类型void(*)(int)，因此可以先用typedef为这个函数指针类型取个别名，然后用类型别名来声明signal函数：
typedef (*sighandler_t)(int);
sighandler_t signal(int, sighandler_t);
相比原来那种让人看着就头大的写法，这种写法是不是一下子清晰多了呢？

5.typedef和cv qualifier结合使用的陷阱
思考以下的例子
typedef char *string;
const string message;
message的实际类型是什么？
如果这样子做替换char * = string，那么const string message就替换成了const char *message，看起来message是一个底层const的指针类型。但这样理解就踩中陷阱了，因为typedef是语义上的类型别名，而不是文本上的等价替换，不能把typedef当作#define使用。typedef char *string表示string在语义上等同于char*类型，那么const string在语义上表示一个不可修改的char*类型，const属性作用于这种类型的变量上，表示变量本身不可修改，也就是指针的指向不可修改。因此，这种const是顶层const，message的实际类型应该是char * const message。
那么有办法用string类型定义一个实际类型等价于const char*的变量吗？很遗憾，没有。在前面的cv qualifier楼中说过，const和string的位置无关紧要，const string message和string const message是相同的语义。这种情况只能使用原始的类型定义char char *message。

6.一些练习题
以上就是解读类型声明的基本内容了，接下来来做一些练习吧
下面这些声明分别代表什么？
int *(*arr[5])();
int *(*(*fp1)(int)) [10];
void **c(char, int (*)(int[][10]));
void * (*arr[5])(const char *, char * const);
写出以下函数/变量的声明
声明一个有10个元素的数组a，每个元素都是一个函数指针，指向的函数有一个const char*参数，函数的返回值是一个char*指针。
声明一个函数指针fp，指向的函数没有参数，返回值为数组指针，指向由3个函数指针构成的数组，每个指针指向一个原型为void f(int)的函数。
声明一个函数func，有两个参数，第一个参数是int，第二个参数是函数指针，指向的函数没有参数，返回值为指向double[3]的数组指针；函数func没有返回值。
可以用typedef来辅助声明。

5怎么被删了