我总是搞砸了怎么用const int*，const int * const和int const *正确的。是否有一组规则定义您可以做什么和不能做什么？

我想知道在分配，传递给函数等方面所有需要做的事情。

向后读取（受“ 顺时针/螺旋规则”驱动）：

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

现在，第一个const可以在类型的任意一侧，因此：

• const int * == int const *
• const int * const == int const * const

如果您想发疯，可以执行以下操作：

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

并确保我们清楚以下含义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样式的字符串，其中有指向的指针const char。您可以更改指向的字符串，但是不能更改这些字符串的内容。当字符串本身位于程序的数据段中并且不应更改时，这一点很重要。

bar是指向可以更改的值的常量或固定指针。这就像没有多余语法糖的参考。因此，通常T* const除非需要允许使用指针，否则通常会在引用中使用NULL指针。

对于那些不了解顺时针/螺旋规则的人：从变量名开始，顺时针移动（在这种情况下，向后移动）到下一个指针或键入。重复直到表达式结束。

这是一个演示：

我认为这里已经回答了所有问题，但是我想补充一点，您应该提防typedefs！它们不只是文本替换。

例如：

typedef char *ASTRING;
const ASTRING astring;

该类型的astring是char * const，没有const char *。这就是我总是倾向于放在const类型右侧的原因，而不是一开始。

几乎每个人都指出：

什么之间的区别const X* p，X* const p以及const X* const p？

您必须从右到左读取指针声明。

• const X* p 表示“ p指向一个X是const”：不能通过p更改X对象。

• X* const p 表示“ p是指向非常量X的const指针”：您不能更改指针p本身，但可以通过p更改X对象。

• const X* const p 表示“ p是指向X的const指针，它是const”：您不能更改指针p本身，也不能通过p更改X对象。

1. 常数参考：

   对常量的变量（此处为int）的引用。我们主要将变量作为参考传递，因为参考的大小小于实际值，但是有副作用，这是因为它就像实际变量的别名。通过完全访问别名，我们可能会意外更改主变量，因此我们将其设为常量以防止这种副作用。

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK

2. 常量指针

   一旦常量指针指向变量，则它不能指向任何其他变量。

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error

3. 指向常量的指针

   不能更改其所指向的变量值的指针称为常量指针。

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error

4. 指向常量的常量指针

   指向常量的常量指针既不能更改其指向的地址，也不能更改保留在该地址的值的指针。

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error

一般规则是，const关键字适用于紧随其后的关键字。例外，以下内容const适用于开始。

• const int*与相同，int const*并表示“指向常数int的指针”。
• const int* const与相同，int const* const并表示“指向常量int的常量指针”。

编辑： 对于该做什么和不该做什么，如果这个答案还不够，您能否更精确地知道自己想要什么？

这个问题正好说明了为什么我喜欢以我在问题中提到的方式在类型ID可接受之后以const的方式进行操作？

总之，我觉得要记住规则最简单的方法是“常量”云后放在要应用的内容。因此，在您的问题中，“ int const *”表示int是常量，而“ int * const”将表示指针是常量。

如果有人决定将其放在最前面（例如：“ const int *”），则在这种情况下，它是一个特殊的例外，适用于其后的事物。

许多人喜欢使用该特殊异常，因为他们认为它看起来更好。我不喜欢它，因为这是一个例外，因此使事情变得混乱。

简单的使用const。

最简单的用法是声明一个命名常量。为此，将一个常量声明为好像是一个变量，const然后在其前面加上一个。一个人必须在构造函数中立即对其进行初始化，因为，当然，一个人以后不能设置该值，因为那会改变它。例如：

const int Constant1=96; 

会创建一个整数常量，这个名字很难想象 Constant1其值，值为96。

此类常数对于程序中使用的参数很有用，但在编译程序后无需更改。与C预处理程序相比，它对程序员具有优势#define命令，因为它可以由编译器本身理解和使用，而不是在到达主编译器之前由预处理程序替换为程序文本，因此错误消息会更有帮助。

它也适用于指针，但是必须小心在哪里const确定指针或其指向的对象是常量还是两者。例如：

const int * Constant2 

声明这Constant2是指向常量整数的变量指针，并且：

int const * Constant2

是一种替代语法，具有相同的功能，而

int * const Constant3

声明这Constant3是指向变量整数的常量指针，并且

int const * const Constant4

声明这Constant4是指向常量整数的常量指针。基本上，“ const”适用于其紧靠左边的任何东西（除非没有什么东西，在这种情况下它适用于其紧靠右边的任何东西）。

参考：http : //duramecho.com/ComputerInformation/WhyHowCppConst.html

在您遇到C ++专家Scott Meyers的这本书之前，我一直和您有同样的疑问。请参阅本书的第三项，他在其中详细介绍了有关使用的内容const。

只要遵循这个建议

1. 如果单词const出现在星号的左侧，则指向的是常量
2. 如果单词const出现在星号的右边，则指针本身是常量
3. 如果const两边都出现，则两者都是常数

简单但棘手。请注意，我们可以交换const与任何数据类型（预选赛int，char，float，等）。

让我们看下面的例子。

const int *p==> *p是只读的[ p是一个指向常量整数的指针]

int const *p==> *p是只读的[ p是一个指向常量整数的指针]

int *p const==> 错误的陈述。编译器将引发语法错误。

int *const p==> p是只读的[ p是指向整数的常量指针]。由于p此处的指针是只读的，因此声明和定义应位于同一位置。

const int *p const ==> 错误的陈述。编译器将引发语法错误。

const int const *p ==> *p是只读的

const int *const p1 ==> *p且p为只读[ p是指向常量整数的常量指针]。由于p此处的指针是只读的，因此声明和定义应位于同一位置。

int const *p const ==> 错误的陈述。编译器将引发语法错误。

int const int *p ==> 错误的陈述。编译器将引发语法错误。

int const const *p ==> *p是只读的，等效于int const *p

int const *const p ==> *p且p为只读[ p是指向常量整数的常量指针]。由于p此处的指针是只读的，因此声明和定义应位于同一位置。

关于C ++中的const正确性，还有许多其他的细微之处。我想这里的问题只是关于C的，但是由于标签是C ++，我将给出一些相关的示例：

• 您通常会传递诸如字符串之类的大参数，TYPE const &以防止对象被修改或复制。范例：

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  但是TYPE & const没有意义，因为引用始终是const。

• 您应该始终将不将类修改的类方法标记为const，否则您将无法从TYPE const &引用中调用该方法。范例：

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• 在通常情况下，返回值和方法都应为const。范例：

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

  实际上，const方法一定不能将内部类数据作为对非const的引用返回。

• 结果，必须经常使用const重载来创建const和非const方法。例如，如果您定义T const& operator[] (unsigned i) const;，那么您可能还需要由给出的非常量版本：

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

Afaik，C中没有const函数，非成员函数本身不能在C ++中是const，const方法可能会产生副作用，并且编译器无法使用const函数来避免重复的函数调用。实际上，即使是简单的int const &引用也可能见证它所引用的值在其他地方被更改。

最初的设计者多次将C和C ++声明语法描述为失败的实验。

相反，让我们将类型命名为“指向”的指针Type；我称它为Ptr_：

template< class Type >
using Ptr_ = Type*;

现在Ptr_<char>是指向的指针char。

Ptr_<const char>是指向的指针const char。

并且const Ptr_<const char>是的const指针const char。

那里。

对我而言，const即相对于左侧或右侧出现还是相对于左侧和右侧出现的位置*有助于我弄清实际含义。

1. constLEFT的A *表示指针所指向的const对象是对象。

2. constRIGHT的A *表示指针是const指针。

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

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

一般惯例。尽一切const可能。或者换一种说法，使所有事情都const开始，然后精确地删除const使程序运行所需的最小s 集。这将对实现const正确性有很大帮助，并且将有助于确保在人们尝试分配不应修改的内容时不会引入细微的错误。

避免像瘟疫一样使用const_cast <>。有一个或两个合法的用例，但它们之间相差无几。如果您要更改一个const对象，那么您会做得更好，以找到谁先声明该对象，const然后与他们讨论此事以达成共识。

这非常巧妙地导致了任务。仅当它是非常量时，才可以分配它。如果要分配给const，请参见上文。请记住，在声明int const *foo;和int * const bar;不同的事情const-在这里其他的答案已经覆盖了这个问题令人钦佩，所以我不会进入它。

功能参数：

按值传递：例如，void func(int param)您不在乎呼叫方的一种方式。可以说有一些用例将函数声明为，void func(int const param)但对调用者没有影响，仅对函数本身没有影响，因为在调用过程中，传递的任何值都不能由函数更改。

通过引用传递：例如，void func(int &param)现在确实有所作为。正如刚刚声明的那样func，允许更改param，并且任何调用站点都应准备好处理后果。更改声明以void func(int const &param)更改合同，并保证func现在不能更改param，这意味着传入的是返回的内容。正如其他人指出的那样，这对于廉价地传递不想更改的大对象非常有用。传递引用比按值传递大对象便宜得多。

通过指针传递：例如void func(int *param)和，void func(int const *param)这两个和它们的参考对应物几乎是同义的，需要警告的是，nullptr除非有其他合同保证不能保证func不会收到nullptrin ，否则被调用函数现在需要检查param。

关于该主题的观点。在这样的情况下证明正确性是非常困难的，犯错误太容易了。因此，不要冒险，并始终检查的指针参数nullptr。从长远来看，您将避免痛苦和痛苦，并且难以发现错误。至于检查的成本，它非常便宜，并且在编译器中内置的静态分析可以管理它的情况下，优化器仍然会忽略它。打开MSVC的链接时间代码生成功能，或者打开GCC的WOPR（我认为）功能，您将在程序范围内使用它，即，即使在跨越源代码模块边界的函数调用中也是如此。

归根结底，上述所有情况都是一个非常可靠的案例，总是喜欢引用指针。他们只是更安全。

两侧都带有int的const将使指向常量int的指针：

const int *ptr=&i;

要么：

int const *ptr=&i;

const之后*将使常量指向int：

int *const ptr=&i;

在这种情况下，所有这些都是指向常量integer的指针，但是这些都不是常量指针：

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

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

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

• 如果const是向左的*，它指的是价值（也不要紧，无论是const int或int const）
• 如果const是向右的*，它指的是指针本身
• 可以同时

重要的一点：const int *p 并不意味着您所指的值是恒定的！。这意味着您不能通过该指针更改它（意味着，您不能分配$ * p = ...`）。该值本身可以以其他方式更改。例如

int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error 

这主要用于函数签名中，以确保函数不会意外更改传递的参数。

只是为了完整起见，请遵循其他说明，对于C ++并不确定。

• pp-指向指针的指针
• p-指针
• 数据-例子中指出的东西 x
• 粗体 -只读变量

指针

• p数据- int *p;
• p 数据 -int const *p;
• p数据-int * const p;
• p 数据 -int const * const p;

指针指向

1. pp p数据- int **pp;
2. pp p数据-int ** const pp;
3. pp p数据-int * const *pp;
4. pp p 数据 -int const **pp;
5. pp p数据-int * const * const pp;
6. pp p 数据 -int const ** const pp;
7. pp p 数据 -int const * const *pp;
8. pp p 数据 -int const * const * const 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);

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

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

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

您不能更改指针的值或int指针所指向的对象的值。

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

该语句等效于1。- const int*您可以更改指针的值，但不能更改int指针指向的对象的值。

实际上，有第四个选择：

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

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

如果要确定某种类型的C或C ++构造，可以使用David Anderson提出的Clockwise / Spiral Rule；但不要与罗斯·安德森（Ross J. Anderson）制定的安德森（Anderson）规则混淆，这是非常不同的。