之间有什么区别：

char * const 

和

const char *

不同的是，const char *是一个指针指向一个const char，而char * const是一个常量指针到char。

首先，指向的值不能更改，但指针可以更改。第二，指向的值可以更改，但指针不能更改（类似于引用）。

还有一个

const char * const

这是指向常量char的常量指针（因此不能更改任何内容）。

注意：

以下两种形式是等效的：

const char *

和

char const *

确切的原因在C ++标准中进行了描述，但重要的是要注意并避免造成混淆。我知道一些喜欢的编码标准：

char const

过度

const char

（使用或不使用指针），以便const元素的位置与使用指针相同const。

为避免混淆，请始终附加 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 总是修改它前面的东西（在它的左边），除非它是类型声明中的第一件事，它修改后面的东西（在它的右边）。

因此，这两个是相同的：

int const *i1;
const int *i2;

它们定义指向的指针const int。您可以更改位置i1和i2指向，但不能更改它们指向的值。

这个：

int *const i3 = (int*) 0x12345678;

定义一个const指向整数的指针，并将其初始化以指向内存位置12345678。您可以更改int地址12345678处的值，但不能更改i3指向的地址。

const * char是无效的C代码，没有意义。也许您是想问a const char *和a 之间的差异char const *，或者a const char *和a 之间的差异char * const？

也可以看看：

• 什么是const指针（与const对象的指针相反）？
• C中的常量
• C ++中const声明之间的区别
• C ++ const问题
• 为什么要更改const char *变量的值？

const char*是指向常量字符的指针是指向字符
char* const的常量指针
const char* const是指向常量字符的常量指针

经验法则：从右到左阅读定义！

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; 将无效。

1. const char * x这里X基本上是一个指向常量值的字符指针

2. char * const x是指常量的字符指针，但是它指向的位置可以更改。

3. const char * const x是1和2的组合，表示它是指向常量值的常量字符指针。

4. const * char x将导致编译器错误。它不能被声明。

5. char const * x等于点1。

经验法则是，如果const是var name，则指针将是恒定的，但是可以更改指向的位置，否则指针将指向恒定的位置，而指针可以指向另一个位置，但是指向的内容不能更改。

第一个是语法错误。也许你的意思是

const char * mychar

和

char * const mychar

在这种情况下，第一个是指向无法更改的数据的指针，第二个是始终指向相同地址的指针。

另一个经验法则是检查const在哪里：

1. * => 之前存储的值是常量
2. * =>之后的指针本身是常量

许多答案提供了特定的技术，经验法则等，以了解此变量声明的特定实例。但是有一种通用的技术可以理解任何声明：

顺时针/螺旋法则

一个）

const char *a;

按照顺时针/螺旋规则a，指向恒定字符的指针。这意味着字符是常量，但指针可以更改。即a = "other string";很好，但a[2] = 'c';将无法编译

B）

char * const a;

按照规则，a是指向字符的const指针。即你可以做，a[2] = 'c';但是你不能做a = "other string";

我想你的意思是const char *和char * const。

第一个，const char *，是指向常量字符的指针。指针本身是可变的。

第二个字符char * const是指向字符的常量指针。指针不能改变，它指向的字符可以。

然后是const char * const，指针和字符无法更改。

这是代码的详细说明

/*const char * p;
char * const p; 
const char * const p;*/ // these are the three conditions,

// const char *p;const char * const p; pointer value cannot be changed

// char * const p; pointer address cannot be changed

// const char * const p; both cannot be changed.

#include<stdio.h>

/*int main()
{
    const char * p; // value cannot be changed
    char z;
    //*p = 'c'; // this will not work
    p = &z;
    printf(" %c\n",*p);
    return 0;
}*/

/*int main()
{
    char * const p; // address cannot be changed
    char z;
    *p = 'c'; 
    //p = &z;   // this will not work
    printf(" %c\n",*p);
    return 0;
}*/



/*int main()
{
    const char * const p; // both address and value cannot be changed
    char z;
    *p = 'c'; // this will not work
    p = &z; // this will not work
    printf(" %c\n",*p);
    return 0;
}*/

// 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’
}

1. 常量指针：在整个程序中，常量指针只能指向相应数据类型的单个变量。我们可以更改指针所指向的变量的值。初始化应该在声明本身的时间内完成。

句法：

datatype *const var;

char *const 在这种情况下。

/*program to illustrate the behaviour of constant pointer */

#include<stdio.h>
int main(){
  int a=10;
  int *const ptr=&a;
  *ptr=100;/* we can change the value of object but we cannot point it to another variable.suppose another variable int b=20; and ptr=&b; gives you error*/
  printf("%d",*ptr);
  return 0;
}

2. 指向const值的指针：在这种情况下，指针可以指向相应类型的任意数量的变量，但是我们无法在该特定时间更改指针所指向的对象的值。

句法：

const datatype *var要么 datatype const *var

const char* 在这种情况下。

/* program to illustrate the behavior of pointer to a constant*/

   #include<stdio.h>
   int main(){
       int a=10,b=20;
       int const *ptr=&a;
       printf("%d\n",*ptr);
       /*  *ptr=100 is not possible i.e we cannot change the value of the object pointed by the pointer*/
       ptr=&b;
       printf("%d",*ptr);
       /*we can point it to another object*/
       return 0;
    }

char * const和const char *？

1. 指向恒定值

const char * p; //值不能更改

2. 指向值的常量指针

char * const p; //地址无法更改

3. 指向常量值的常量指针

const char * const p; //两者都无法更改。

该const修改将立即应用于术语其左。唯一的例外是，当左边没有任何东西时，则适用于右边的东西。

这些都是说“指向常量的常量指针”的等效方法char：

• const char * const
• const char const *
• char const * const
• char const const *

两条规则

1. If const is between char and *, it will affect the left one.
2. If const is not between char and *, it will affect the nearest one.

例如

1. char const *. This is a pointer points to a constant char.
2. char * const. This is a constant pointer points to a char.

我想指出的是，int const *（或 const int *）与指向const int变量的指针无关，而是该变量const用于该特定指针。

例如：

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

上面的代码可以完美地编译。_p指向const变量，尽管var它本身不是常数。

我记得捷克书中有关C的文章：请阅读以变量开头并向左走的声明。因此对于

char * const a;

您可以将其理解为：“ a是类型为常量指针的变量，char”，

char const * a;

您可以读为：a是char类型常量变量的指针。我希望这会有所帮助。

奖金：

const char * const a;

您将按原样阅读achar类型的常量变量。