没有人提到Kernighan和Ritchie在其C书中指出的系统声明：

声明模拟表达式。

我将重复这一点，因为它非常重要，并且给出了一个清晰的策略来解析最复杂的声明：

声明模拟表达式。

声明包含的运算符与声明的标识符可以在后面出现的表达式相同，在表达式中具有相同的优先级。这就是为什么“顺时针螺旋法则”是错误的：求值顺序严格由操作员优先级决定，完全不考虑左、右或旋转方向。

以下是几个示例，按复杂性增加的顺序排列：

整数i；：当i按原样使用时，它是int类型的表达式。因此，i是int。int*p；：当p用*解引用时，表达式的类型为int。因此，p是指向int的指针。常量int*p；：当p用*解引用时，表达式的类型为const int。因此，p是指向const int的指针。int*常量p；：p是常量。如果此常量表达式用*解引用，则该表达式的类型为int。因此，p是int的常量指针。常量int*常量p；：p是常量。如果此常量表达式用*解引用，则该表达式的类型为const int。因此，p是指向const int的常量指针。

到目前为止，我们还没有遇到运算符优先级的任何问题：我们只是从右到左计算。当我们使用指针数组和指向数组的指针时，这会发生变化。你可能想打开一张备忘单。

int a[3]；：当我们对a应用数组索引运算符时，结果是int。因此，a是int的数组。int*a[3]；：这里，索引运算符具有更高的优先级，因此我们首先应用它：当我们将数组索引运算符应用于时，结果是int*。因此，a是指向int的指针数组。这并不罕见。int（*a）[3]；：这里，运算符优先级被圆括号覆盖，与任何表达式中的完全相同。因此，我们首先取消引用。我们现在知道a是指向某种类型的指针*a、 解引用指针是该类型的表达式。当我们将数组索引运算符应用于*a时，我们获得了一个纯int，这意味着*a是一个由三个int组成的数组，a是指向该数组的指针。这在C++模板之外是相当罕见的，这就是为什么运算符优先级不适合这种情况的原因。请注意，使用这样的指针是如何实现其声明的模型：int i=（*a）[1]；。括号必须先取消引用。int（*a）[3][2]；：没有什么能阻止任何人拥有指向多维数组的指针，在这种情况下，圆形螺旋顺时针方向的建议变得毫无意义。

在现实生活中有时会出现函数指针。我们也需要括号，因为函数调用运算符（C++中的operator（），C中的简单语法规则）比解引用运算符*（）具有更高的优先级，再次因为函数返回指针比函数指针更常见：

int*f（）；：首先调用函数，所以f是一个函数。调用必须被解引用才能产生int，因此返回值是指向int的指针。用法：int i=*f（）；。int（*fp）（）；：括号更改运算符应用程序的顺序。因为我们必须首先取消引用，所以我们知道fp是指向某个对象的指针。因为我们可以将函数调用运算符应用于*fp，所以我们知道（在C中）fp是指向函数的指针；在C++中，我们只知道它是定义了运算符（）的对象。由于调用不接受参数并返回int，因此fp在C++中是指向具有该签名的函数的指针。（在C中，空的参数列表表示对参数一无所知，但未来的C规范可能会禁止这种过时的使用。）int*（*fp）（）；：当然，我们可以从指向的函数返回指向int的指针。int（*（*fp）（））[3]；：首先取消引用，因此是指针；接下来应用函数调用运算符，因此是指向函数的指针；再次取消引用返回值，因此指向返回指针的函数的指针；将索引运算符应用于：返回数组指针的函数指针。结果是一个int，因此指向函数的指针返回指向int数组的指针-所有的括号都是必要的：正如所讨论的，我们必须在发生任何其他事情之前，优先使用（*fp）取消函数指针的引用。显然，我们需要函数调用；而且由于函数返回一个指向数组的指针（而不是指向它的第一个元素！），所以我们必须在索引它之前取消引用它。我承认我写了一个测试程序来检查这一点，因为我不确定，即使使用这种防错方法；-）。这里是：

#include <iostream>
using namespace std;

int (*f())[3]
{
  static int arr[3] = {1,2,3};
  return &arr;
}

int (*(*fp)())[3] = &f;

int main()
{
  for(int i=0; i<3; i++)
  {
    cout << (*(*fp)())[i] << endl;
  }
}

请注意，声明模仿表达式是多么美妙！

常量参考：对变量（此处为int）的引用，该变量是常量。我们主要将变量作为引用传递，因为引用的大小比实际值小，但有一个副作用，这是因为它像实际变量的别名。通过对别名的完全访问，我们可能会意外地更改主变量，因此我们将其设置为常量以防止这种副作用。int var0=0；常量int&ptr1=var0；ptr1=8；//错误var0=6；//好啊常量指针一旦常量指针指向一个变量，那么它就不能指向任何其他变量。int var1=1；int var2=0；int*const ptr2=&var1；ptr2=&var2；//错误指向常量的指针不能改变所指向变量值的指针称为常量指针。int const*ptr3=&var2；*ptr3=4；//错误指向常量的常量指针指向常量的常量指针是一个既不能改变它所指向的地址，也不能改变保存在该地址的值的指针。int var3=0；int var4=0；const int*const ptr4=&var3；*ptr4=1；//错误ptr4=&var4；//错误

两边带有int的常量将使指针指向常量int：

const int *ptr=&i;

or:

int const *ptr=&i;

*后的const将使常量指针指向int：

int *const ptr=&i;

在这种情况下，所有这些都是指向常量整数的指针，但没有一个是常量指针：

 const int *ptr1=&i, *ptr2=&j;

在这种情况下，所有指针都指向常量整数，ptr2是指向常量整数的常量指针。但ptr1不是常量指针：

int const *ptr1=&i, *const ptr2=&j;

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是C语言中的关键字，也称为限定符。Const罐应用于任何变量的声明，以指定其值不会改变

const int a=3,b;

a=4;  // give error
b=5;  // give error as b is also const int 

you have to intialize while declaring itself as no way to assign
it afterwards.

如何阅读？

只需从右到左阅读每一条语句即可顺利完成

3件主要事情

type a.    p is ptr to const int

type b.    p is const ptr to int 
 
type c.    p is const ptr to const int

[错误]

if * comes before int 

两种类型

1. const int *

2. const const int *

我们先看

主要类型1。常量int*

在3个地方安排3件事的方法3=6.

i.*开始时

*const int p      [Error]
*int const p      [Error]

二。开始时常量

const int *p      type a. p is ptr to const int 
const *int p      [Error]

iii.开始时int

int const *p      type a. 
int * const p     type b. p is const ptr to int

主要类型2。常量常量int*

在4个地方安排4件事情的方法，其中2件是相同的4件/2!=12

i.*开始时

* int const const p     [Error]
* const int const p     [Error]
* const const int p     [Error]
 

二。开始时为int

int const const *p      type a. p is ptr to const int
int const * const p     type c. p is const ptr to const int
int * const const p     type b. p is const ptr to int

iii.启动时的常量

const const int *p     type a.
const const * int p    [Error]

const int const *p      type a.
const int * const p     type c.

const * int const p    [Error]
const * const int p    [Error]

挤成一体

类型a.p是常量int（5）的指针

const int *p
int const *p

int const const *p
const const int  *p
const int  const *p

类型b.p是int（2）的常量指针

int * const p
int * const const p;

类型c.p是const ptr到const int（2）

int const * const p
const int * const p

只是很少的计算

1. const int * p        total arrangemets (6)   [Errors] (3)
2. const const int * p  total arrangemets (12)  [Errors] (6)

小小的额外

int常量*p，p2；

here p is ptr to const int  (type a.) 
but p2 is just const int please note that it is not ptr

int*常量p，p2；

similarly 
here p is const ptr to int  (type b.)   
but p2 is just int not even cost int

int常量*常量p，p2；

here p is const ptr to const int  (type c.)
but p2 is just const int. 

完成了

这主要涉及第二行：最佳实践、分配、功能参数等。

一般做法。尽可能使一切保持稳定。或者换一种说法，从一开始就让所有的常量都是常量，然后完全删除允许程序运行所需的最小常量集。这将大大有助于实现常量正确性，并有助于确保在人们尝试分配不应该修改的内容时不会引入细微的错误。

避免像瘟疫一样的const_cast＜＞。它有一两个合法的使用案例，但它们非常少。如果你试图改变一个常量对象，你会做得更好，找到第一步中声明它常量的人，并与他们讨论此事，以就应该发生的事情达成共识。

这很好地引导到作业中。只有当它是非常量时，才能将其赋值。如果您想分配给常量，请参见上文。请记住，在声明中int const*foo；和int*const bar；不同的东西是恒定的——这里的其他答案都很好地涵盖了这个问题，所以我就不赘述了。

功能参数：

传递值：例如，voidfunc（int-param），在调用站点，你不在乎这一种方式或另一种方式。可以这样做，即存在将函数声明为void func（int const param）的用例，但这对调用方没有影响，只对函数本身没有影响，因为函数在调用期间不能更改传递的任何值。

通过引用传递：例如，void func（int&param）现在它确实起了作用。正如刚才声明的，func可以更改参数，任何调用站点都应该准备好处理结果。将声明更改为void func（int const&param）将更改约定，并保证func现在不能更改param，这意味着传入的内容将返回。正如其他人所指出的，这对于便宜地传递不想更改的大型对象非常有用。传递引用比按值传递大型对象要便宜得多。

传递指针：例如，void func（int*param）和void func（int const*param）这两个与它们的引用对应项几乎同义，但需要注意的是，被调用的函数现在需要检查nullptr，除非其他契约保证func不会在param中收到nullpter。

关于这个话题的评论文章。在这种情况下证明正确性非常困难，犯错误太容易了。所以不要冒险，总是检查指针参数的nullptr。从长远来看，你会让自己免于痛苦和痛苦，并且很难找到bug。至于检查的成本，它非常便宜，在编译器中内置的静态分析可以管理它的情况下，优化器无论如何都会取消它。为MSVC启用“链接时间代码生成”，或为GCC启用“WOPR（我认为）”，您将在程序范围内获得它，即即使在跨越源代码模块边界的函数调用中。

在一天结束时，以上所有内容都证明了一个非常可靠的理由，即总是倾向于引用指针。他们只是更安全。