往右优先。再往左。遇到最后一个右边的符号带上返回值。
优先级 [] > () > *
注：函数的指针==函数指针 存放数组的数组 == 二维数组
标有ILLEGAL的声明 为强行翻译。
如果有错误，希望大家可以多多指正。不理解评论区可以留言。
练习int i; //an int
//i是int类型
int *p; //an int pointer (ptr to an int)
//p是一个int型指针
int a[]; //an array of ints
//a是一个存放int的数组
int f(); //a function returning an int
//f是一个返回值是int的函数
int **pp; //a pointer to an int pointer (ptr to a ptr to an int)
//*pp是一个指针 int **pp 是指向int指针的指针
int (*pa)[]; //a pointer to an array of ints
(*pa) pa是一个指针
(*pa)[] pa指向数组
int (*pa)[] pa是一个指向int数组的指针
int (*pf)(); //a pointer to a function returning an int
(*pf)() pf是一个指向函数的指针
int (*pf)() pf是一个指向返回值是int函数的指针 -- 函数指针
int *ap[]; //an array of int pointers (array of ptrs to ints)
ap[] ap是一个数组
int *ap[] ap是一个存放int指针的数组
int aa[][]; //an array of arrays of ints
aa[] aa是一个数组
aa[][] aa是一个每个位置都是数组的数组
int aa[][] aa是一个存放int的二维数组
int af[](); //an array of functions returning an int (ILLEGAL)
af[] af是一个数组
af[]() 是一个存放函数的数组
int af[]() af是一个存放返回值是int的函数的数组
int *fp(); //a function returning an int pointer
fp() fp是一个函数
int *fp() fp是一个返回值是int指针的函数
int fa()[]; //a function returning an array of ints (ILLEGAL)
fa()是一个函数 fa()[]fa是一个函数数组
int fa()[] fa是一个返回值是int数组的函数
int ff()(); //a function returning a function returning an int
ff() ff是一个函数
ff()() ff是一个返回函数的函数
int ff()() ff是一个返回值是int的函数的函数
// (ILLEGAL)
int ***ppp; //a pointer to a pointer to an int pointer
*ppp ppp是一个指针
**ppp ppp是一个指向指针的指针
int ***ppp ppp是一个指向int指针的指针的指针
int (**ppa)[]; //a pointer to a pointer to an array of ints
**ppa 是一个指向指针的指针
(**ppa)[] ppa是一个指向数组的指针的指针
int (**ppa)[] ppa是一个指向存放int数组的指针的指针
int (**ppf)(); //a pointer to a pointer to a function returning an int
**ppf ppf是一个指向指针的指针
(**ppf)() ppf是一个指向函数的指针的指针
int (**ppf)() ppf是一个指向返回值是int的函数的指针的指针
int *(*pap)[]; //a pointer to an array of int pointers
*pap pap是一个指针
(*pap)[] pap是一个指向数组的指针
int *(*pap)[] pap是一个指向存放int指针的数组指针
int (*paa)[][]; //a pointer to an array of arrays of ints
paa是一个指向存放int的数组的数组的指针
int (*paf)[](); //a pointer to a an array of functions returning an int
(*paf)[] paf是一个指向数组的指针
(*paf)[]() paf是一个指向存放函数的数组指针
int (*paf)[]() paf是一个指向存放返回值是int的函数的数组指针
// (ILLEGAL)
int *(*pfp)(); //a pointer to a function returning an int pointer
(*pfp)() pfp是一个指向函数的指针
int *(*pfp)() pfp是一个指向返回值是int指针的函数指针
int (*pfa)()[]; //a pointer to a function returning an array of ints
(*pfa)() pfa是一个指向函数的指针
(*pfa)()[] pfa是一个指向返回值是数组的函数指针
int (*pfa)()[] pfa是一个指向返回值是存放int数组的函数指针
// (ILLEGAL)
int (*pff)()(); //a pointer to a function returning a function
(*pff)() pff是一个指向函数的指针
(*pff)()() pff是一个指向返回值是函数的函数指针
int (*pff)()() pff是一个指向返回值是 返回值为int的函数 的函数指针
// returning an int (ILLEGAL)
int **app[]; //an array of pointers to int pointers
app[] app是一个数组
int **app[] app是一个存放指向int的指针的指针的数组
int (*apa[])[]; //an array of pointers to arrays of ints
apa[] apa是一个数组
(*apa[]) apa是一个存放指针的数组
(*apa[])[] apa是一个存放 指向数组的指针 的数组
int (*apa[])[] apa是一个存放 指向int数组的指针 的数组
int (*apf[])(); //an array of pointers to functions returning an int
*apf[] apf是一个存放指针的数组
(*apf[])() apf是一个存放函数指针的数组
int (*apf[])() apf是一个存放 返回值是int的函数指针的数组
int *aap[][]; //an array of arrays of int pointers
aap[] app是一个数组
aap[][] app是一个存放数组的数组
int *aap[][] app是一个存放int指针的数组的数组
int aaa[][][]; //an array of arrays of arrays of ints
aaa[] aaa是一个数组
aaa[][] aaa是一个存放数组的数组
aaa[][][] aaa是一个存放数组的数组的数组
int aaa[][][] aaa是一个存放int的数组的数组的数组
int aaf[][](); //an array of arrays of functions returning an int
aaf[][] aaf是一个存放数组的数组
aaf[][]() aaf是一个存放函数的数组的数组
int aaf[][]() aaf是一个存放返回值是int 的函数的数组的数组
// (ILLEGAL)
int *afp[](); //an array of functions returning int pointers (ILLEGAL)
afp[]() afp是一个存放函数的数组
int *afp[]() afp是一个存放返回值是int指针的函数的数组
int afa[]()[]; //an array of functions returning an array of ints
afa[]() afa是一个存放函数的数组
afa[]()[] afa是一个存放返回值是数组的函数的数组
int afa[]()[] afa是一个存放返回值是int数组的函数的数组
// (ILLEGAL)
int aff[]()(); //an array of functions returning functions
aff[]() aff是一个存放函数的数组
aff[]()() aff是一个存放返回值是函数的函数的数组
int aff[]()() aff是一个存放返回值是int函数的函数的数组
// returning an int (ILLEGAL)
int **fpp(); //a function returning a pointer to an int pointer
fpp() fpp是函数
int **fpp() fpp是一个返回值是指向int的指针的指针的函数
int (*fpa())[]; //a function returning a pointer to an array of ints
(*fpa()) fpa是一个返回值是指针的函数
(*fpa())[] fpa是一个返回值是指向数组的指针的函数
int (*fpa())[] fpa是一个指向int数组的指针的函数
int (*fpf())(); //a function returning a pointer to a function
*fpf() fpf是返回值是指针的函数
(*fpf())() fpf是一个返回值是函数的指针的函数
int (*fpf())() fpf是一个返回值是int的函数的指针的函数
// returning an int
int *fap()[]; //a function returning an array of int pointers (ILLEGAL)
fap()[] fap是一个返回值是数组的函数
int *fap()[]是一个返回值是int指针的数组的函数
int faa()[][]; //a function returning an array of arrays of ints
faa()[] faa是一个返回值是数组的函数
faa()[][] faa是一个返回值是数组的数组的函数
int faa()[][] faa是一个返回值是int的数组的数组的函数
// (ILLEGAL)
int faf()[](); //a function returning an array of functions
faf()[] faf是一个返回值是数组的函数
faf()[]() faf是一个返回值是存放函数数组的函数
int faf()[]() faf是一个返回值是存放 返回值是int函数 的数组的函数
// returning an int (ILLEGAL)
int *ffp()(); //a function returning a function
ffp() ffp是一个函数
ffp()() ffp是一个返回值是函数的函数
int *ffp()() ffp是一个返回值是 int指针的函数 的函数
// returning an int pointer (ILLEGAL)
char (*(*x())[])();
x() x是一个函数
(*x()) x是一个返回值是指针的函数
(*x())[] x是一个返回值是指向数组的函数
(*(*x())[]) x是一个返回值是指向 存放指针的数组 的函数
(*(*x())[])() x是一个返回值是指向 存放函数的指针的数组 的函数
char (*(*x())[])() x是一个返回值是指向 存放返回值是函数的指针的数组 的函数
//x: function returning pointer to array[] of pointer to function returning char
char (*(*x[3])())[5];
//x: array[3] of pointer to function returning pointer to array[5] of char
char (*(*x[])())[];
*x[] x是一个存放指针的数组
(*x[])() x是一个存放函数的指针的数组
(*(*x[])()) x是一个存放 返回值是指针的函数的指针 的数组
(*(*x[])())[] x是一个存放 返回值是数组指针的函数的指针 的数组
char (*(*x[])())[]x是一个存放 返回值是char数组指针的函数的指针 的数组
参考博客
https://blog.csdn.net/sooqing/article/details/1680700
https://blog.csdn.net/truefriend/article/details/1849427
