查看C++书的时候，碰巧看到一个函数声明
bool Sales_item::same_isbn (const Sales_item * const this, const Sales_item &rhs) const
意思是：当一个函数被声明为常量成员函数(const member function)，
这时隐藏的this指针被标记成 const Sales_item * const this, 是的，这里有两个const。
下面的这篇文章教导人们如何快速的阅读 C Declarations。
给出三个实例。 断言为 *a = b 是合法的。
const int * a = &b; // 假
int const * a = &b; // 假
int * const a = &b; // 真
ZZ from http://blogold.chinaunix.net/u1/36290/showart_443799.html
Even experienced C programmers have difficulty reading declarations that go beyond simple arrays and pointers. For example, is the following an array of pointers or a pointer to an array?
int *a[10];
What the heck does the following mean?
int (*(*vtable)[])();
Naturally, it’s a pointer to an array of pointers to functions returning integers. 😉
This short article tells you how to read any C declaration correctly using a very simple technique. I am 99% certain that I read this in a book in the late 1980s, but I can’t remember where. I doubt that I discovered this on my own (even though I’ve always been delighted by computer language structure and esoterica). I do remember, however, building a simple program that would translate any declaration into English.
The golden rule
The rule goes like this:
"Start at the variable name (or innermost construct if no identifier is present. Look right without jumping over a right parenthesis; say what you see. Look left again without jumping over a parenthesis; say what you see. Jump out a level of parentheses if any. Look right; say what you see. Look left; say what you see. Continue in this manner until you say the variable type or return type."
这条规律是这样的:
从变量名（或者是一个最深处的结构）开始，先看他右边一个命名，不要越过右括号(即遇到括号放弃)，说出你看到的，然后再看他的左边一个命名，同样不越过当前层左括号，说出你看到的，一次循环后，如果这次遇到了阻挡，那么跳出这对括号；依次反复，直到读完所有的变量。
我或许可以模糊的告诉你大意，但是我认为更好的办法就是阅读原文（直接看英语更利于你理解）。起码该自己阅读下面的话：
The degenerate case is:
int i;
Starting at i, you look right and find nothing. You look left and find the type int, which you say. Done.
Ok, now a more complicated one:
int *a[3];
Start at a. Look right, say array of size 3. Look left and say pointer. Look right and see nothing. Look left and say int. All together you say a is an array of size 3 pointers to int.
Adding parentheses is when it gets weird:
int (*a)[3];
The parentheses change the order just like in an expression. When you look right after a, you see the right parenthesis, which you cannot jump over until you look left. Hence, you would say a is a pointer to an array of 3 ints.
Function pointers
The C "forward" declaration:
extern int foo();
just says that foo is a function returning int. This follows the same pattern for reading declarators as you saw in previous section. Start at foo and look right. You see () so say function. You look left and see int. Say int.
Now, try this one:
extern int *foo();
Yep, you say foo is a function returning a pointer to int.
Now for the big leap. Just like we can make a pointer to an int or whatever, let’s make a pointer to a function. In this case, we can drop the extern as it’s no longer a function forward reference, but a data variable declaration. Here is the basic pattern for function pointer:
int (*foo)();
You start at foo and see nothing to the right. So, to the left, you say pointer. Then to the right outside you see function. Then left you see int. So you say foo is a pointer to a function returning int.
Combinations
Here is an array of pointers to functions returning int, which we’ll need for vtables below:
int (*Object_vtable[])();
You need one last, incredibly bizarre declaration, for the lab:
int (*(*vtable)[])();
This is the pointer to the vtable you will need in each "object" you define.
This pointer to a vtable is set to the address of a vtable; for example, &Truck_vtable.
Summary
The following examples summarize the cases needed for building virtual tables ala C++ to implement polymorphism (like the original cfront C++ to C translator).
int *ptr_to_int;
int *func_returning_ptr_to_int();
int (*ptr_to_func_returning_int)();
int (*array_of_ptr_to_func_returning_int[])();
int (*(*ptr_to_an_array_of_ptr_to_func_returning_int)[])();
