轉：如何理解c和c ++的複雜類型聲明

標籤：元素   無法   window   函數指標   方式   個數   混合   顯示   argv   

本文作者girlrong是網易廣州社區的C語言版版主，這篇文章被選在精華區。很是不錯，不敢獨享！據說她樂於助人，虛心誠懇，頗受網友歡迎。只可惜現在已退隱江湖了。在最近學習C語言過程中，瞭解些前輩大牛的經驗看法

 

曾經碰到過讓你迷惑不解、類似於int * (* (*fp1) (int) ) [10];這樣的變數聲明嗎？

本文將由易到難，一步一步教會你如何理解這種複雜的C/C++聲明。

我們將從每天都能碰到的較簡單的聲明入手，然後逐步加入const修飾符和typedef，還有函數指標，最後介紹一個能夠讓你準確地理解任何C/C++聲明的“右左法則”。

需要強調一下的是，複雜的C/C++聲明並不是好的編程風格；我這裡僅僅是教你如何去理解這些聲明。注意：為了保證能夠在同一行上顯示代碼和相關注釋，本文最好在至少1024x768解析度的顯示器上閱讀。

讓我們從一個非常簡單的例子開始，如下：

int n;

這個應該被理解為“declare n as an int”（n是一個int型的變數）。接下去來看一下指標變數，如下：

int *p;

這個應該被理解為“declare p as an int *”（p是一個int *型的變數），或者說p是一個指向一個int型變數的指標。我想在這裡展開討論一下：我覺得在聲明一個指標（或引用）類型的變數時，最好將*（或&）寫在緊靠變數之前，而不是緊跟基本類型之後。這樣可以避免一些理解上的誤區，比如：

再來看一個指標的指標的例子：

char **argv;

理論上，對於指標的級數沒有限制，你可以定義一個浮點類型變數的指標的指標的指標的指標，再來看如下的聲明：

int RollNum[30][4];

int (*p)[4]=RollNum;

int *q[5];

這裡，p被聲明為一個指向一個4元素（int類型）數組的指標，而q被聲明為一個包含5個元素（int類型的指標）的數組。另外，我們還可以在同一個聲明中混合實用*和&，如下：

int **p1;

// p1 is a pointer  to a pointer  to an int.

int *&p2;

// p2 is a reference to a pointer  to an int.

int &*p3;

// ERROR: Pointer  to a reference is illegal.

int &&p4;

// ERROR: Reference to a reference is illegal.

註：p1是一個int類型的指標的指標；p2是一個int類型的指標的引用；p3是一個int類型引用的指標（不合法！）；p4是一個int類型引用的引用（不合法！）。

 

const修飾符

當你想阻止一個變數被改變，可能會用到const關鍵字。在你給一個變數加上const修飾符的同時，通常需要對它進行初始化，因為以後的任何時候你將沒有機會再去改變它。例如：

const int n=5;

int const m=10;

上述兩個變數n和m其實是同一種類型的——都是const int（整形恒量）。因為C++標準規定，const關鍵字放在類型或變數名之前等價的。我個人更喜歡第一種聲明方式，因為它更突出了const修飾符的作用。當const與指標一起使用時，容易讓人感到迷惑。例如，我們來看一下下面的p和q的聲明：

const int *p;

int const *q;

他們當中哪一個代表const int類型的指標（const直接修飾int），哪一個代表int類型的const指標（const直接修飾指標）？實際上，p和q都被聲明為const int類型的指標。而int類型的const指標應該這樣聲明：

int * const r= &n;

// n has been declared as an int

這裡，p和q都是指向const int類型的指標，也就是說，你在以後的程式裡不能改變*p的值。而r是一個const指標，它在聲明的時候被初始化指向變數n（即r=&n;）之後，r的值將不再允許被改變（但*r的值可以改變）。

 

組合上述兩種const修飾的情況，我們來聲明一個指向const int類型的const指標，如下：

const int * const p=&n

// n has been declared as const int

 

下面給出的一些關於const的聲明，將協助你徹底理清const的用法。不過請注意，下面的一些聲明是不能被編譯通過的，因為他們需要在聲明的同時進行初始化。為了簡潔起見，我忽略了初始化部分；因為加入初始化代碼的話，下面每個聲明都將增加兩行代碼。

char ** p1;

//    pointer to    pointer to    char

const char **p2;

//    pointer to    pointer to const char

char * const * p3;

//    pointer to const pointer to    char

const char * const * p4;

//    pointer to const pointer to const char

char ** const p5;

// const pointer to    pointer to    char

const char ** const p6;

// const pointer to    pointer to const char

char * const * const p7;

// const pointer to const pointer to    char

const char * const * const p8;

// const pointer to const pointer to const char

 

註：p1是指向char類型的指標的指標；p2是指向const char類型的指標的指標；p3是指向char類型的const指標；p4是指向const char類型的const指標；p5是指向char類型的指標的const指標；p6是指向const char類型的指標的const指標；p7是指向char類型const指標的const指標；p8是指向const char類型的const指標的const指標。

 

typedef的妙用

typedef給你一種方式來克服“*只適合於變數而不適合於類型”的弊端。你可以如下使用typedef：

typedef char * PCHAR;

PCHAR p,q;

這裡的p和q都被聲明為指標。（如果不使用typedef，q將被聲明為一個char變數，這跟我們的第一眼感覺不太一致！）下面有一些使用typedef的聲明，並且給出瞭解釋：

typedef char * a;

// a is a pointer to a char

typedef a b();

// b is a function that returns

// a pointer to a char

typedef b *c;

// c is a pointer to a function

// that returns a pointer to a char

typedef c d();

// d is a function returning

// a pointer to a function

// that returns a pointer to a char

typedef d *e;

// e is a pointer to a function

// returning a pointer to a

// function that returns a

// pointer to a char

e var[10];

// var is an array of 10 pointers to

// functions returning pointers to

// functions returning pointers to chars.

 

typedef經常用在一個結構聲明之前，如下。這樣，當建立結構變數的時候，允許你不使用關鍵字struct（在C中，建立結構變數時要求使用struct關鍵字，如struct tagPOINT a；而在C++中，struct可以忽略，如tagPOINT b）。

typedef struct tagPOINT

{

  int x;

  int y;

}POINT;

 

POINT p;

 

函數指標

函數指標可能是最容易引起理解上的困惑的聲明。函數指標在DOS時代寫TSR程式時用得最多；在Win32和X-Windows時代，他們被用在需要回呼函數的場合。當然，還有其它很多地方需要用到函數指標：虛函數表，STL中的一些模板，Win NT/2K/XP系統服務等。讓我們來看一個函數指標的簡單例子：

int (*p)(char);

這裡p被聲明為一個函數指標，這個函數帶一個char類型的參數，並且有一個int類型的傳回值。另外，帶有兩個float型別參數、傳回值是char類型的指標的指標的函數指標可以聲明如下：

char ** (*p)(float, float);

那麼，帶兩個char類型的const指標參數、無傳回值的函數指標又該如何聲明呢？參考如下：

void * (*a[5])(char * const, char * const);

“右左法則”是一個簡單的法則，但能讓你準確理解所有的聲明。這個法則運用如下：從最內部的括弧開始閱讀聲明，向右看，然後向左看。當你碰到一個括弧時就調轉閱讀的方向。括弧內的所有內容都分析完畢就跳出括弧的範圍。這樣繼續，直到整個聲明都被分析完畢。

 

對上述“右左法則”做一個小小的修正：當你第一次開始閱讀聲明的時候，你必須從變數名開始，而不是從最內部的括弧。

下面結合例子來示範一下“右左法則”的使用。

int * (* (*fp1) (int) ) [10];

閱讀步驟：

1. 從變數名開始——fp1

2. 往右看，什麼也沒有，碰到了)，因此往左看，碰到一個*——一個指標

3. 跳出括弧，碰到了(int)——一個帶一個int參數的函數

4. 向左看，發現一個*——（函數）返回一個指標

5. 跳出括弧，向右看，碰到[10]——一個10元素的數組

6. 向左看，發現一個*——指標

7. 向左看，發現int——int類型

總結：fp1被聲明成為一個函數的指標,該函數返回指向指標數組的指標.

 

再來看一個例子：

int *( *( *arr[5])())();

閱讀步驟：

1. 從變數名開始——arr

2. 往右看，發現是一個數組——一個5元素的數組

3. 向左看，發現一個*——指標

4. 跳出括弧，向右看，發現()——不帶參數的函數

5. 向左看，碰到*——（函數）返回一個指標

6. 跳出括弧，向右發現()——不帶參數的函數

7. 向左，發現*——（函數）返回一個指標

8. 繼續向左，發現int——int類型

 

還有更多的例子：

float ( * ( *b()) [] )();

// b is a function that returns a

// pointer to an array of pointers

// to functions returning floats.

void * ( *c) ( char, int (*)());

// c is a pointer to a function that takes

// two parameters:

// a char and a pointer to a

// function that takes no

// parameters and returns

// an int

// and returns a pointer to void.

void ** (*d) (int &,

char **(*)(char *, char **));

// d is a pointer to a function that takes

// two parameters:

// a reference to an int and a pointer

// to a function that takes two parameters:

// a pointer to a char and a pointer

// to a pointer to a char

// and returns a pointer to a pointer

// to a char

// and returns a pointer to a pointer to void

float ( * ( * e[10])

  (int &) ) [5];

// e is an array of 10 pointers to

// functions that take a single

// reference to an int as an argument

// and return pointers to

// an array of 5 floats.

 

 補充：

C語言所有複雜的指標聲明，都是由各種聲明嵌套構成的。如何解讀複雜指標聲明呢？右左法則是一個既著名又常用的方法。不過，右左法則其實並不是C標準裡面的內容，它是從C標準的聲明規定中歸納出來的方法。C標準的聲明規則，是用來解決如何建立聲明的，而右左法則是用來解決如何辯識一個聲明的，兩者可以說是相反的。右左法則的英文原文是這樣說的：

The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.


這段英文的翻譯如下：

右左法則：首先從最裡面的圓括弧看起，然後往右看，再往左看。每當遇到圓括弧時，就應該掉轉閱讀方向。一旦解析完圓括弧裡面所有的東西，就跳出圓括弧。重複這個過程直到整個聲明解析完畢。

        筆者要對這個法則進行一個小小的修正，應該是從未定義的標識符開始閱讀，而不是從括弧讀起，之所以是未定義的標識符，是因為一個聲明裡面可能有多個標識符，但未定義的標識符只會有一個。

        現在通過一些例子來討論右左法則的應用，先從最簡單的開始，逐步加深：

int (*func)(int *p);

首先找到那個未定義的標識符，就是func，它的外面有一對圓括弧，而且左邊是一個*號，這說明func是一個指標，然後跳出這個圓括弧，先看右邊，也是一個圓括弧，這說明(*func)是一個函數，而func是一個指向這類函數的指標，就是一個函數指標，這類函數具有int*類型的形參，傳回值類型是int。

int (*func)(int *p, int (*f)(int*));

func被一對括弧包含，且左邊有一個*號，說明func是一個指標，跳出括弧，右邊也有個括弧，那麼func是一個指向函數的指標，這類函數具有int *和int (*)(int*)這樣的形參，傳回值為int類型。再來看一看func的形參int (*f)(int*)，類似前面的解釋，f也是一個函數指標，指向的函數具有int*類型的形參，傳回值為int。

int (*func[5])(int *p);

func右邊是一個[]運算子，說明func是一個具有5個元素的數組，func的左邊有一個*，說明func的元素是指標，要注意這裡的*不是修飾func的，而是修飾func[5]的，原因是[]運算子優先順序比*高，func先跟[]結合，因此*修飾的是func[5]。跳出這個括弧，看右邊，也是一對圓括弧，說明func數組的元素是函數類型的指標，它所指向的函數具有int*類型的形參，傳回值類型為int。


int (*(*func)[5])(int *p);

func被一個圓括弧包含，左邊又有一個*，那麼func是一個指標，跳出括弧，右邊是一個[]運算子號，說明func是一個指向數組的指標，現在往左看，左邊有一個*號，說明這個數組的元素是指標，再跳出括弧，右邊又有一個括弧，說明這個數組的元素是指向函數的指標。總結一下，就是：func是一個指向數組的指標，這個數組的元素是函數指標，這些指標指向具有int*形參，傳回值為int類型的函數。

int (*(*func)(int *p))[5];

func是一個函數指標，這類函數具有int*類型的形參，傳回值是指向數組的指標，所指向的數組的元素是具有5個int元素的數組。

要注意有些複雜指標聲明是非法的，例如：

int func(void) [5];

func是一個傳回值為具有5個int元素的數組的函數。但C語言的函數傳回值不能為數組，這是因為如果允許函數傳回值為數組，那麼接收這個數組的內容的東西，也必須是一個數組，但C語言的數組名是一個右值，它不能作為左值來接收另一個數組，因此函數傳回值不能為數組。

int func[5](void);

func是一個具有5個元素的數組，這個數組的元素都是函數。這也是非法的，因為數組的元素除了類型必須一樣外，每個元素所佔用的記憶體空間也必須相同，顯然函數是無法達到這個要求的，即使函數的類型一樣，但函數所佔用的空間通常是不相同的。

作為練習，下面列幾個複雜指標聲明給讀者自己來解析，答案放在第十章裡。

int (*(*func)[5][6])[7][8];

int (*(*(*func)(int *))[5])(int *);

int (*(*func[7][8][9])(int*))[5];

實際當中，需要聲明一個複雜指標時，如果把整個聲明寫成上面所示的形式，對程式可讀性是一大損害。應該用typedef來對聲明逐層分解，增強可讀性，例如對於聲明：

int (*(*func)(int *p))[5];

可以這樣分解：

typedef  int (*PARA)[5];
typedef PARA (*func)(int *);

這樣就容易看得多了。

轉：如何理解c和c ++的複雜類型聲明