C/C++ 复杂声明-优快云博客

本文链接：https://blog.youkuaiyun.com/kevenbalabala/article/details/125069241

复杂声明

往右优先。再往左。遇到最后一个右边的符号带上返回值。

优先级 () > [] > *

注：函数的指针==函数指针存放数组的数组 == 二维数组

标有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数组指针的函数的指针 的数组

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数组指针的函数的指针的数组