轉貼部落格

• C 語言:輕鬆讀懂複雜的定義 (Define and Read the complex declarations)

• C 語言:輕鬆讀懂複雜的定義 (Define and Read the complex declarations)

from : http://magicjackting.pixnet.net/blog/post/60889356-c-%E8%AA%9E%E8%A8%80:%E8%BC%95%E9%AC%86%E8%AE%80%E6%87%82%E8%A4%87%E9%9B%9C%E7%9A%84%E5%AE%9A%E7%BE%A9-(define-and-read-the-co

The "right-left" rule is a completely regular rule for deciphering C declarations. It can also be useful in creating them.

First, symbols. Read

• * as "pointer to" - always on the left side
• [] as "array of" - always on the right side
• () as "function returning" - always on the right side

as you encounter them in the declaration.

註一: 我們中文比較習慣的是說法是 指向...的指標, 元素內容為...的陣列, 回傳值為...的函式, 但是這樣的語法會使得我們相對的容易把修飾對象搞混, 尤其是語法中的符號數量很多的時候. 因此在這裡我比照英文的次序翻譯, 最後再進一步的轉換成我們比較習慣的說法. 同時, 請注意後面的 ... 修飾的對象就是它前面的 指標, 陣列或函式.

STEP 1

Find the identifier. This is your starting point. Then say to yourself, "identifier is". You've started your declaration.

STEP 2

Look at the symbols on the right of the identifier. If, say, you find "()"there, then you know that this is the declaration for a function. So you would then have "identifier is function returning". Or if you found a "[]"there, you would say "identifier is array of". Continue right until you run out of symbols *OR* hit a *right* parenthesis ")". (If you hit a left parenthesis, that's the beginning of a () symbol, even if there is stuff in between the parentheses. More on that below.)

STEP 3

Look at the symbols to the left of the identifier. If it is not one of our symbols above (say, something like "int"), just say it. Otherwise, translate it into English using that table above. Keep going left until you run out of symbols *OR* hit a *left* parenthesis "(".

Now repeat steps 2 and 3 until you've formed your declaration. Here are some examples:

int *p[];

註二: 重新順一下, 轉成我們平常慣用的中文說法: p 是一個陣列, 此陣列的元素是指向 (int) 的指標. (抱歉, 功力不佳, 一對一翻真的沒辦法翻得非常順.)

Another example:

int *(*func())();

註三: 轉成我們平常慣用的中文說法是: func 是一個函式, 此函式的回傳值是指向函式的指標, 而該函式的回傳值是指向 int 的指標.

As you can see, this rule can be quite useful. You can also use it to sanity check yourself while you are creating declarations, and to give you a hint about where to put the next symbol and whether parentheses are required.

Some declarations look much more complicated than they are due to array sizes and argument lists in prototype form. If you see "[3]", that's read as "array (size 3) of...". If you see "(char *,int)" that's read as "function expecting (char *,int) and returning...". Here's a fun one:

int (*(*fun_one)(char *,double))[9][20];

I won't go through each of the steps to decipher this one.

Ok. It's:

"fun_one is pointer to function expecting (char *,double) and returning pointer to array (size 9) of array (size 20) of int."

註四: 轉成我們平常慣用的中文說法是: fun_one 是一個指向函式的指標, 此函式的傳入參數是 (char *, double), 回傳值是指向陣列的指標, 而該陣列含有 9 個元素, 元素的內容是 20 個 int 的陣列.

As you can see, it's not as complicated if you get rid of the array sizes and argument lists:

int (*(*fun_one)())[][];

You can decipher it that way, and then put in the array sizes and argument lists later.

Some final words:

It is quite possible to make illegal declarations using this rule, so some knowledge of what's legal in C is necessary. For instance, if the above had been:

int *((*fun_one)())[][];

it would have been "fun_one is pointer to function returning array of array of pointer to int". Since a function cannot return an array, but only a pointer to an array, that declaration is illegal.

Illegal combinations include:

• []() - cannot have an array of functions
• ()() - cannot have a function that returns a function
• ()[] - cannot have a function that returns an array

In all the above cases, you would need a set of parens to bind a * symbol on the left between these () and [] right-side symbols in order for the declaration to be legal.

Here are some legal and illegal examples: