对我来说，常量的位置，即它相对于*是出现在左侧还是右侧，还是同时出现在左侧和右侧，有助于我理解实际含义。

*左边的常量表示指针指向的对象是常量对象。*右边的常量表示指针是常量指针。

下表摘自斯坦福CS106L标准C++编程实验室课程阅读器。

为了C遵循其他解释的完整性，对C++不确定。

pp-指针到指针p-指针数据-在示例x中指出的内容粗体-只读变量

指针

p数据-int*p；p数据-int常量*p；p数据-int*const p；p数据-int const*const p；

指向指针的指针

pp p数据-int**pp；pp p数据-int**const pp；pp p数据-int*const*pp；pp p数据-int常量**pp；pp p数据-int*const*const pp；pp p数据-int const**const pp；pp p数据-int const*const*pp；pp p数据-int常量*常量*常量pp；

// Example 1
int x;
x = 10;
int *p = NULL;
p = &x;
int **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 2
int x;
x = 10;
int *p = NULL;
p = &x;
int ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 3
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 4
int const x = 10; // Definition must happen during declaration
int const * p = NULL;
p = &x;
int const **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 5
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 6
int const x = 10; // Definition must happen during declaration
int const *p = NULL;
p = &x;
int const ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 7
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 8
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

N级取消引用

继续前进，但愿人类将你逐出教会。

int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;

printf("%d \n", ****pppp);

const int*-指向常量int对象的指针。

您可以更改指针的值；不能更改指针指向的int对象的值。

const int*const-指向常量int对象的常量指针。

不能更改指针的值，也不能更改指针指向的int对象的值。

int const*-指向常量int对象的指针。

此语句相当于1。constint*-可以更改指针的值，但不能更改指针指向的int对象的值。

实际上，还有第四种选择：

int*const-指向int对象的常量指针。

可以更改指针指向的对象的值，但不能更改指针本身的值。指针将始终指向同一个int对象，但此int对象的值可以更改。

如果你想确定某种类型的C或C++结构，你可以使用David Anderson制定的顺时针/螺旋规则；但不要与罗斯·J·安德森（Ross J.Anderson）制定的安德森规则混淆，这是一个非常独特的规则。

一般规则是const关键字应用于它前面的内容。异常，起始常量适用于以下内容。

constint*与intconst*相同，表示“指向常量int的指针”。const int*const与int const*const相同，表示“指向常量int的常量指针”。

编辑：对于该做的和不该做的，如果这个答案还不够，你能更准确地说出你想要什么吗？

反向阅读（由顺时针/螺旋法则驱动）：

int*-指向int的指针int const*-指向const int的指针int*const-指向int的const指针int const*const-指向const int的const指针

现在，第一个常量可以位于类型的任一侧，因此：

常量int*==int常量*const int*const==int const*const

如果你想变得疯狂，你可以这样做：

int**-指向int指针的指针int**const-指向int指针的const指针int*const*-指向int的const指针int const**-指向常量int的指针int*const*const-指向int的常量指针的常量指针...

为了确保我们清楚const的含义：

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

foo是指向常量整数的变量指针。这允许您更改指向的内容，但不更改指向的值。最常见的情况是，C样式字符串中有一个指向常量字符的指针。您可以更改指向的字符串，但不能更改这些字符串的内容。当字符串本身位于程序的数据段中且不应更改时，这一点很重要。

bar是指向可更改值的常量或固定指针。这就像没有额外语法糖的引用。由于这一事实，通常您会在使用T*常量指针的地方使用引用，除非您需要允许NULL指针。

在我读到C++大师斯科特·梅耶斯（Scott Meyers）的这本书之前，我和你一样心存疑虑。请参阅本书中的第三项，其中他详细介绍了如何使用const。

只需遵循以下建议

如果单词const出现在星号的左侧，则所指向的是常量如果单词const出现在星号的右侧，则指针本身是常量如果常量出现在两侧，则两者都是常量