1. 理解C语言的声明

声明主要由声明器、类型说明符、类型限定符和存储属性组成

1.1. 声明器（declarator）

1) 指针

                * const volatile

                * volatile

                *

                * const

                * volatile const

                指针的五种限定形式

2) 数组

                类型 标识符[下标]

3) 函数

                类型 标识符(参数列表)

1.2. 类型说明符

1) void char short int long signed unsigned float double

2) 结构体struct

3) 枚举enum

4) 联合体union

1.3. 类型限定符

1) const

2) volatile可以放在类型前面，也可以放在后面

1.4. 存储属性

1) static

2) extern

3) register

4) auto

5) typedef针对标识符（名称）

1.5. 声明的限制

1) 非法

            函数的返回值不能为函数

            函数的返回值不能为数组

            数组中不能有函数

            函数的参数不能为函数

2) 合法

            函数的返回值可以是函数指针

                void (*func(void))(int)

            函数的返回值可以是指向数组的指针

                int(*func(void))[10]

            数组中可以有函数指针

                void (*array[10])(int)

            函数的参数可以是函数指针

                void func(void (*)(int))

1.6. 声明组成的优先级规则

1) 从名字开始

2) 优先级顺序

            声明中被括起来的部分

            后缀操作符

                括号（）表示是一个函数

                方括号[ ]表示是一个数组

            前缀操作符

                星号 * 表示是”指向……的指针“

3) const或volatile关键字

            如果后面紧跟着类型说明符（如int，long等），则作用于类型说明符

            其他情况下，作用于左边紧邻的星号 *，表示指针常量（指针不可变）

4) 整体思路

            从里往外

            从右到左

            一找函数

            二找数组

            三找指针

 

2. 练习题

详细解释说明如下所列的声明

char *ptr;

char const *ptr;

const char *ptr;

char * const ptr;

char * const *ptr;

 

int demo1(int);

int *demo2(int);

int (*demo2)(int);

int (*demo3(int))(void);

int (*(*demo4)(int))(void);

int (*(*demo5[10])(int))(void);

int (*(*(*demo6)[10])(int))(void);

int (*(*(*demo7)[10])(void (*cb)(int)))(void);

int (*(*(*const demo8)[10])(void (*cb)(int)))(void);

int * const * (*(*demo9)[10])(void (*cb)(int));

int * const * (*(*demo10)[10])(int (*(*cb)(int))[10]);

习题分步讲解：

char  *ptr;

        ptr   //名称是ptr

       * //ptr是一个指向...的指针

char        //char类型的数据

/*ptr是一个指向char类型数据的指针。*/

 

 

char const *ptr;

              ptr  //名称是ptr 

             *      //ptr是一个指向...的指针

char const        //char类型的const常量

/*ptr是一个指向char类型const常量数据的指针。*/

 

const char *ptr;

              ptr //名称是ptr 

             *      //ptr是一个指向...的指针

const char        //char类型的const常量

/*ptr是一个指向char类型const常量数据的指针。*/

 

char * const ptr;

               Ptr //名称是ptr，ptr是一个...

      * const    //指向...的指针常量

char             //char类型数据

/*ptr是一个指向char类型数据的指针常量。*/

 

char * const *ptr;

                 ptr //名称是ptr

                *     //ptr是指向...的指针

      * const        //指向...的指针常量

char                //char型数据

/*ptr是指向一个指向char型数据的指针常量 的指针。*/

 

 

int demo1(int);

     demo1         //名称是demo1

int       (int);  //demo1是一个函数，参数是int，返回值int

/*demo1是一个带有一个int型参数，返回值为int类型的函数。*/

 

int *demo2(int);

      demo2       //名称是demo2

     *     (int); //demo2是一个函数，参数是int，返回一个指向...的指针int               //int类型数据

/*demo2是一个带有一个int型参数，返回值为一个指向int类型数据的指针。*/

 

int (*demo2)(int);

       demo2         //名称是demo2，demo2是一个...

      *               //指向...的指针int (      )(int);  //一个函数，参数是int，返回一个int类型数据

/*demo2是一个指向函数的指针，函数有一个int类型参数，返回一个int类型数据。*/

 

int (*demo3(int))(void);

       demo3                //名称是demo3

      *     (int)  //demo3是一个函数，参数是int，返回一个指向...的指针

int (           )(void);  //一个函数，参数是void，返回一个int类型数据

/*demo3是一个带有一个int型参数，返回值为一个没有参数的函数，函数返回值为int的函数指针。*/

 

int (*(*demo4)(int))(void);

          demo4             //名称是demo4

        *                    //demo4是指向...的指针

      *(       )(int)       //一个函数,参数int，返回指向...的指针

int (              )(void); //一个函数,无参数，返回int

/*demo4是指向一个带有一个int型参数，返回一个无参数返回值为int的函数指针的函数的指针。*/

 

int (*(*demo5[10])(int))(void);

          demo5                     //名称是demo5

               [10]                 //demo5是一个有10个...类型数据元素的数组

        *                            //指向...的指针

      *(          )(int)           //一个函数，参数是int，返回一个指向...的指针

int (                  )(void);   //一个函数，无参数，返回一个int类型的数据

/*demo5是一个有10个函数指针为元素的指针数组，指针数组元素指向的函数是带有一个int型参数，返回一个无参数返回值为int的函数指针的函数。*/

 

int (*(*(*demo6)[10])(int))(void);

            demo6                     //名称是demo6

           *                          //demo6是一个指向...的指针

         *(      )[10]                //有10个元素的数组，数组元素类型是指向...的指针

       *(             )(int)          //一个函数，参数是int，返回一个指向...的指针

int (                     )(void);  //一个函数，无参数，返回一个int类型的数据

 

int (*(*(*demo7)[10])(void (*cb)(int)))(void);

            demo7                              //名称demo7

           *                                    //demo7是一个指向...的指针

        *(      )[10]                          //有10个元素的数组，数据元素类型是指向...的指针

      *(             )(    . . . .    )      //一个函数，参数是...，返回值为一个指向...的指针

      *(             )(      *        )        //一个函数，参数是一个指向...的指针，返回值为一个指向...的指针

      *(             )(void (   )(int))     //一个函数，参数是一个指向一个函数（参数int）的指针，返回值为一个指向...的指针

int (                                 )(void); //一个函数，无参数，返回值为int类型数据

/*demo7是一个指向有10个函数指针为元素的数组的指针，指针数组元素指向的函数是以一个带一个int型参数返回为空的函数指针为参数，返回一个无参数返回值为int的函数指针的函数。*/

 

int (*(*(*const demo8)[10])(void (*cb)(int)))(void);

                   demo8                                 //名称是demo8

           *const                                       //demo8是一个指向...的指针常量

        *(            )[10]                            //有10个元素的数组，元素数据类型是指向...的指针

     *(                   )(   . . . . .   )          //一个函数，参数是...，返回值为一个指向...的指针

                                      *                   //一个指向...的指针

                              void (   )(int)           //一个函数，参数是int，返回void

int (                                       )(void);   //一个函数，参数是void，返回int

/*demo8是一个指向有10个函数指针为元素的数组的指针常量（指针不可变），指针数组元素指向的函数是以一个带一个int型参数返回为空的函数指针为参数，返回一个无参数返回值为int的函数指针的函数。*/

 

int * const * (*(*demo9)[10])(void (*cb)(int));

                     demo9                           //名称是demo9

                    *                                //demo9是一个指向...的指针

                  *(      )[10]                      //有10个元素的数组，元素数据类型是指向...的指针

               * (             )(    . . . .    )    //一个函数，参数是...，返回值为一个指向...的指针

                                         *             //     参数是一个指向...的指针

                                  void (   )(int)     //     一个函数，参数是int，返回void

 * const                                       //指向...的指针常量

int                                               //int类型数据

/*demo9是一个指向有10个函数指针为元素的数组的指针，指针数组元素指向的函数，是以一个带一个int型参数返回为空的函数指针为参数，返回指向一个int类型数据的指针常量的指针。*/

 

int * const * (*(*demo10)[10])(int (*(*cb)(int))[10]);

                     demo10                                //demo10

                    *                                      //demo10是一个指向...的指针

                  *(       )[10]                           //有10个元素的数组，元素数据类型是指向...的指针

               * (              )(     .  .  .  .      );  //一个函数，参数是...，返回值为一个指向...的指针

                                   (       *             );  //     参数是一个指向...的指针

                                   (     *(   )(int)     );  //     一个函数，参数是int，返回一个指向...的指针 

                                   (int (           )[10]);  //     一个有10个元素的数组，数组元素类型是int

 * const                                             //指向...的指针常量

int                                                     //int类型数据