犹记得当第一次看见c的signal函数的原型的时候，懵逼了，这是个啥啊

1
2
3
typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

现在知道了，借助typedef声明了一个函数指针类型取名叫sighandler_t，这个函数指针
返回值是void，入参是int。然后声明了signal函数，signal函数的返回值是sighandler_t
这个类型的函数指针。
typedef可以帮我们简化复杂类型的声明，在不借助typedef的情况下，c语言应该怎么声明复杂的类型呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <stdio.h>
#include "stdlib.h"

/**
 * 复习关于C语言复杂类型的声明定义
 */
int main(void)
{
    /**
     * c语言语法中，[]、()的优先级最高，[]、()写在标识符的右侧，*号和基本类型，如int,char,struct等
     * 写在标识符左侧,对声明定义的解析是右左原则。
     */

    /**
     * 指针p指向一个有20个char类型元素的数组
     */
    char (*p)[20];
    p=(char(*)[20])malloc(20);
    free(p);

    int a[20];
    int (*p_a)[20] = &a;
    /**
     * 二级指针就多加个*
     */
    int (**pp_a)[20] = &p_a;
    typedef int(*p_array)[];
    p_array * p_c = &p_a;// 跟int (**pp_a)[20] = &p_a;等效
    p_array** p_d = &p_c;

    int *b[20];
    int *(*p_b)[20] = &b;
    int *(**p_e)[20] = &p_b;


    /*************************************/
    /**
     * 定义一个数组，数组有20个元素，每个元素是指向int类型的二级指针
     */
    int** f[20];
    /**
     * 定义一个指针，该指针指向一个数组，该数组有20个元素，每个元素是指向int类型的二级指针
     */
    int** (*p_f)[20] = &f;

    /**
     * 定义一个20个元素的数组g，该数组的每个元素是一个指针，
     * 该指针指向一个有10个元素的数组,该数组的元素是指向char*
     * 类型的指针
     */
    char *(*g[20])[10];

    /**
     * 定义一个20个元素的数组，数组的每一个元素是一个指针，该指针是函数指针，
     * 该函数指针指向的函数，入参为int,返回值是int
     *
     */
    int (*h[20])(int);

    /**
     * 定义一个指针指向二维int型数组
     * 
     */

    int i[2][12];
    int (*p_i)[][12] = &i;
    int (*p_i1)[12] = i; // 数组名i代表的是以数组元素为类型的指向数组首地址的指针

    /**
     * 定义一个函数指针func，指向的函数没有入参，返回值是一个指针，
     * 该指针指向一个二维数组，该二维数组的每一元素是有10个元素的一维数组，
     * 一维数组的元素是int*指针
     */
    int *(*(*func)(void))[][10];

    /**
     * 定义一个函数指针func_a，指向的函数入参是int,返回值是函数指针，
     * 该函数指针指向的函数入参是int,返回值是int*
     * 1.首先是个指针,所以在左侧加*号，得到*func_a
     * 2.变成函数指针，入参是int，得到(*func_a)(int)
     * 3.返回值是函数指针，那么把2的结果作为一个整体看待，看作是标识符,
     *   再在左侧加*号，后边加(int),得到(*(*func_)(int))(int)
     * 4.返回值的函数指针指向的函数返回值是int*，所以再在左边加上int*，
     * 最后得到 int *(*(*func_a)(int))(int)
     */
    int *(*(*func_a)(int))(int);

    /**
     * 定义一个数组指针pg，该指针指向一个20个元素的数组，该数组的元素是
     * 函数指针，该函数指针指向的函数，入参是int,返回值是int
     */
     int (*(*pg)[20])(int);
     pg = &h;

    /**
     * 定义一个函数指针func_b，指向的函数入参是int，返回值是一个指针，
     * 该指针指向一个20个元素的数组，该数组的元素是函数指针，
     * 该函数指针指向的函数，入参是int,返回值是int.
     */
     int (*(*(*func_b)(int b))[20])(int);

     /**
      * 定义一个数组指针ph,指向一个有20个元素的数组，该数组的元素是函数指针，
      * 该指针指向一个函数，该函数的入参是int,返回值是指针，该指针指向一个10
      * 个元素的数组，该元素char *
      */
     char* (*(*(*ph)[20])(int))[10];

     /**
      * 定义一个函数指针func_d，入参是int,返回值是函数指针，该函数指针指向的函数
      * 入参是short, 返回值是一个指向包含15个char*类型的数组的指针
      */
      char *(*(*(*func_d)(int))(short))[15];

    return 0;
}