傑克! 真是太神奇了!

本文來自網站 ieng9.ucsd.edu (http://ieng9.ucsd.edu/~cs30x/rt_lt.rule.html) 加以重新排版.

呃… 它搬家了, 新網址如後: cseweb.ucsd.edu (http://cseweb.ucsd.edu/~ricko/rt_lt.rule.html)

本文開始: (修訂二版)

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 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:
以下是一些合於語法和不合語法的例子:

本文結束.

2023/01/06

我重新 review 了一遍譯文, 並做了一些詞彙上的修訂和附加註解, 好讓它讀起來順暢一些. 同時也修正一處原文的錯誤 (來自舊原文站; 新原文站已修正).