入門階段，看見類似void * (*(*fp1)(int))[10];的複雜宣告，暈乎。直接略過，這種複雜的東東，不應該是入門者需要去學習的知識。

進階階段，這種知識就必需得搞得清清楚楚了，不然還等到高階階段才學習這個麼？

現在，就來帶大家瞭解一下，這類複雜的宣告怎麼解？

在解之前，先看一個入門的知識點，指標函式作為引數傳遞。

1. int func_call(string text) {  
2.     cout <<text<<endl;  
3.     return 5;  
4. }  
5. void func_pointer(int (*fp)(string)) {  
6.     cout <<fp("func_pointer") <<endl;  
7. }  
8. void main() {  
9.     int (*fp)(string);//宣告函式指標，此函式接受一個字串引數並返回一個整型  
10.     fp = func_call;  
11.     func_pointer(fp);//將函式指標作為引數傳遞  
12. }  

1. void * (*(*fp1)(int))[10];

2. float (*(*fp2)(int,int,float))(int);

解1：void * (*(*fp1)(int))[10];

解2：float (*(*fp2)(int,int,float))(int);

（1）包含fp2的最內層小括號是(*fp2)：fp2是指標
（2）往(*fp2)右邊看是(int,int,float),右邊是小括號即是函式：指向帶有3個引數的函式
（3）再往(*fp2)左邊看是*，當右邊是函式，左邊即是函式的返回值：且函式返回一個指標
（4）往(*(*fp2)(int,int,float))右邊看是(int)，右邊小括號表示函式：指標指向帶1個整型引數的函式
（5）再往(*(*fp2)(int,int,float))左邊看是float，即是函式的返回值：函式返回float

把整段話拼出來：

fp2是指標，指向帶有3個引數的函式，且函式返回一個指標，指標指向帶1個整型引數的函式，函式返回float

任何複雜的宣告都按此方法解，中間的變數名開始，右--左--右--左。編譯器也是按此步驟讀宣告的。

下面程式碼示例：

1. typedefvoid* (*AP)[10];  
2. AP func_fp1(int i) {  
3.     cout<< "func_fp1:" << i << endl;  
4.     AP a = nullptr;  
5.     return a;  
6. }  
7. void main() {  
8.     void * (*(*fp1)(int))[10];  
9.     fp1 = func_fp1;  
10.     (*fp1)(5);  
11. }  

1. void main() {  
2.     AP (*fp1)(int);  
3.     fp1 = func_fp1;  
4.     (*fp1)(5);  
5. }  

1. float func_f(int i) {  
2.     cout<< "func_f:" << i << endl;  
3.     return 1.0f;  
4. }  
5. typedeffloat (*FP)(int);  
6. FP func_fp2(int i,int j,float f) {  
7.     cout<< "func_fp2 i:" << i << ", j:" << j << ", f:" << f << endl;  
8.     //float (*fp)(int);
9.     FP fp;  
10.     fp = func_f;  
11.     return fp;  
12. }  
13. void main() {  
14.     float (*(*fp2)(int,int,float))(int);  
15.     fp2 = func_fp2;  
16.     (*(*fp2)(1,2,3))(4);  
17. }  

1. void main() {  
2.     FP (*fp3)(int,int,float);  
3.     fp3 = func_fp2;  
4.     (*(*fp3)(5,6,7))(8);  
5. }