引入

  • 我们在编写C/C++代码时，常常会遇到类似如下的复杂声明

    int board[8][8];        // 声明一个指向 int 数组的数组
int **ptr;              // 声明一个指向指针的指针，被指向的指针指向 int
int *risks[10];         // 声明一个内含10个元素的数组，每个元素都是一个指向 int 的指针
int (*rusk)[10];        // 声明一个指向数组的指针，该数组内含10个 int 类型的值
int *oof[3][4];         // 声明一个3*4的二维数组，每个元素都是指向 int 的指针
int (*uuf)[3][4];       // 声明一个指向3*4二维数组的指针，该数组中内含 int 类型的值
int (*uof[3])[4];       // 声明一个内含3个元素的数组，其中每个指针都指向一个内含4个 int 类型值的数组

  • 对此，我们可以按照以下黄金法则进行快速判断(参考 bilibili 视频)

黄金法则

1、找到变量名，如果没有变量名，就找到最内层的结构
2、向右按顺序看完，直到括号，读出你看到的东西，但不要跳过括号
3、再向左按顺序看完，直到括号，读出你看到的东西，但也不要跳过括号
4、现在如果有括号的话，跳出一层括号
5、重复上述过程，直到读出最终的类型
6、以上方法同时适用于变量和函数，包括函数指针。此外对于解读const也可以使用这个顺序

一些具体示例

  • int *v[5];

    1、找到变量 v
    2、向右看，v 是个数组，数组尺寸 5
    3、向左看，数组每个元素是指针，再向左，指向 int
    4、最终：v是一个尺寸 5 的数组，每个元素是指向 int 的指针(v 是有 5 个指向 int 的指针的数组)

  • int (*v)[5];

    1、找到变量 v
    2、向右看，没东西(遇到括号)
    3、向左看，v 是个指针
    4、跳出一层括号，向右看，指向一个有 5 个元素的数组
    5、向左看，数组类型是int 类型
    6、最终：v是一个指向有 5 个 int 类型值的数组的指针

  • int (*func)();

    1、先看最内层，找到func
    2、向右看，没东西(遇到括号)
    3、向左看，func 是个指针
    4、跳出一层括号，向右看，是个函数
    5、向左看，函数的返回值是 int 型
    6、最终：func是个指针，指向一个返回 int 型的函数(这就是函数指针)

  • int (*v[])();

    1、先看最内层，找到v
    2、向右看，v 是个数组
    3、向左看，数组每个元素是指针
    4、跳出一层括号，向右看，每个指针指向函数
    5、向左看，函数的返回值是 int 型
    6、最终：v是一个int 型函数指针组成的数组

  • int (*(*v)[])();

    1、先看最内层，找到v
    2、向左看，v 是个指针(省略向右的说明，有括号)
    3、跳出一层括号，向右看，指向一个数组
    4、向左看，数组每个元素是指针
    5、跳出一层括号，向右看，数组元素的指针指向一个函数
    6、向左看，函数的返回值是 int 型
    7、最终：v是一个指向 int 型函数指针组成的数组的指针

页底评论