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

我猜你指的是const char *和char * const。

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

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

然后是const char * const，指针和字符不能改变。

区别在于const char *是指向const char的指针，而char * const是指向char的常量指针。

首先，被指向的值不能改变，但指针可以改变。第二，被指向的值可以改变，但指针不能改变(类似于引用)。

还有一个

const char * const

它是一个指向常量char的常量指针(因此它的任何内容都不能更改)。

注意:

以下两种形式是等价的:

const char *

而且

char const *

具体的原因在c++标准中有描述，但重要的是要注意并避免混淆。我知道一些编码标准更喜欢:

char const

在

const char

(带或不带指针)，以便const元素的位置与指针const的位置相同。

第一个是语法错误。也许你指的是两者的区别

const char * mychar

而且

char * const mychar

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

const * char是无效的C代码，没有意义。也许你想问const char *和char const *之间的区别，或者可能是const char *和char * const之间的区别?

参见:

• 什么是const指针(相对于指向const对象的指针)?< / >
• C中的Const
• c++中const声明的差异
• c++ const question .
• 为什么我可以改变一个const char*变量的值?< / >

const总是修改它前面的东西(在它的左边)，除非它是类型声明中的第一个东西，在那里它修改后面的东西(在它的右边)。

所以这两个是一样的

int const *i1;
const int *i2;

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

这样的:

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

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

为了避免混淆，总是附加 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;

1. 这里x基本上是一个字符指针，指向一个常数值

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

3. const char* const x是1和2的组合，意味着它是一个指向常量值的常量字符指针。

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

5. char const * x =点1。

经验法则是，如果常量带有var名称，则指针将是常数，但指向的位置可以改变，否则指针将指向一个固定的位置，指针可以指向另一个位置，但指向的位置内容不能更改。

另一个经验法则是检查常量是:

1. *之前 => 价值存储为常数
2. 后* => 指针本身就是常数

这里是一个详细的解释与代码

/*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 *varor 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; // value不能改变

2. 指向值的常量指针

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

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

const char * const p; //两者都不能改变。

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

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

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.

许多答案提供了具体的技术，经验法则等，以理解变量声明的特殊实例。但是有一个通用的技巧来理解任何声明:

顺时针/螺旋规则

.

一)

const char *a;

根据顺时针/螺旋规则，a是指向常量字符的指针。这意味着字符是不变的，但指针可以改变。例如，a = "other string";是好的，但a[2] = 'c';将无法编译

B)

char * const a;

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

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

例如:

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

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

我记得从捷克书关于C:阅读声明，你从变量开始，向左走。 所以对于< / p >

char * const a;

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

char const * a;

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

奖金:

const char * const a;

你将读到a是指向char类型常量变量的常量指针。