为了避免混淆，总是附加const限定符。

int       *      mutable_pointer_to_mutable_int;
int const *      mutable_pointer_to_constant_int;
int       *const constant_pointer_to_mutable_int;
int const *const constant_pointer_to_constant_int;

Const char*是一个指向常量字符的指针 Char * const是一个指向字符的常量指针 Const char* Const是一个指向常量字符的常量指针

我记得捷克的一本关于C的书:读声明，你从变量开始向左走。 因此,对于

char * const a;

你可以读成:“a是指向char的常量指针类型的变量”，

char const * a;

你可以读成:“a是一个指向char类型常量变量的指针。我希望这能有所帮助。

奖金:

const char * const a;

您将读取为指向char类型的常量变量的is常量指针。

// Some more complex constant variable/pointer declaration.
// Observing cases when we get error and warning would help
// understanding it better.

int main(void)
{
  char ca1[10]= "aaaa"; // char array 1
  char ca2[10]= "bbbb"; // char array 2

  char *pca1= ca1;
  char *pca2= ca2;

  char const *ccs= pca1;
  char * const csc= pca2;
  ccs[1]='m';  // Bad - error: assignment of read-only location ‘*(ccs + 1u)’
  ccs= csc;    // Good

  csc[1]='n';  // Good
  csc= ccs;    // Bad - error: assignment of read-only variable ‘csc’

  char const **ccss= &ccs;     // Good
  char const **ccss1= &csc;    // Bad - warning: initialization from incompatible pointer type

  char * const *cscs= &csc;    // Good
  char * const *cscs1= &ccs;   // Bad - warning: initialization from incompatible pointer type

  char ** const cssc=   &pca1; // Good
  char ** const cssc1=  &ccs;  // Bad - warning: initialization from incompatible pointer type
  char ** const cssc2=  &csc;  // Bad - warning: initialization discards ‘const’
                               //                qualifier from pointer target type

  *ccss[1]= 'x'; // Bad - error: assignment of read-only location ‘**(ccss + 8u)’
  *ccss= ccs;    // Good
  *ccss= csc;    // Good
  ccss= ccss1;   // Good
  ccss= cscs;    // Bad - warning: assignment from incompatible pointer type

  *cscs[1]= 'y'; // Good
  *cscs= ccs;    // Bad - error: assignment of read-only location ‘*cscs’
  *cscs= csc;    // Bad - error: assignment of read-only location ‘*cscs’
  cscs= cscs1;   // Good
  cscs= cssc;    // Good

  *cssc[1]= 'z'; // Good
  *cssc= ccs;    // Bad - warning: assignment discards ‘const’
                 //                qualifier from pointer target type
  *cssc= csc;    // Good
  *cssc= pca2;   // Good
  cssc= ccss;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cscs;    // Bad - error: assignment of read-only variable ‘cssc’
  cssc= cssc1;   // Bad - error: assignment of read-only variable ‘cssc’
}

经验法则:从右向左阅读定义!

Const int *foo;

意思是“foo指向(*)一个不能改变的int (const)”。 对于程序员来说，这意味着“我不会改变foo所指向的值”。

*foo = 123;或者foo[0] = 123;是无效的。 Foo = &bar;是被允许的。

Int *const foo;

意思是“foo不能改变(const)并将(*)指向int”。 对于程序员来说，这意味着“我不会改变foo引用的内存地址”。

*foo = 123;或者foo[0] = 123;是被允许的。 Foo = &bar;是无效的。

Const int * Const foo;

意思是“foo不能改变(const)并将(*)指向一个不能改变的int (const)”。 对于程序员来说，这意味着“我不会改变foo所指向的值，也不会改变foo所指向的地址”。

*foo = 123;或者foo[0] = 123;是无效的。 Foo = &bar;是无效的。

我想指出，使用int const *(或const int *)不是关于指向const int变量的指针，而是这个变量对于这个特定的指针是const的。

例如:

int var = 10;
int const * _p = &var;

上面的代码可以很好地编译。_p指向一个const变量，尽管var本身不是常量。