关于C#：char * const和const char *有什么区别？

What is the difference between char * const and const char *?

有什么区别：

1	char * const

和

1	const char *

相关讨论

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

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

还有一个

1	const char * const

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

注：

以下两种形式是等效的：

1	const char *

和

1	char const *

在C++标准中描述了这一点的确切原因，但是注意并避免混淆是很重要的。我知道一些编码标准，它们更喜欢：

1	char const

结束

1	const char

(有指针或无指针)使const元素的位置与指针const元素的位置相同。

相关讨论

如果在同一声明中指定了多个变量，是否值得注意发生了什么？我相信const int *foo,*bar;会宣布foo和bar都是int const *，但int const *foo, *bar会宣布foo是int const *和bar是int *。我认为typedef int * intptr; const intptr foo,bar;会将两个变量都声明为int * const；我不知道如何使用组合声明来创建没有typedef的该类型的两个变量。
@Supercat I believe const int *foo,*bar; would declare both foo and bar to be int const *是的。埃多克斯1〔12〕不！这与前一种情况完全相同。(请参见ideone.com/rsab7n，其中foo和bar的错误相同)。埃多克斯一〔13〕是的。以东十一〔14〕号：嗯，以东十一〔15〕号。C声明符语法…
@GX：所以我错了——我的不确定性就是为什么我建议说规则是什么可能会有帮助。int const *foo, *volatile bar会对bar做什么？把它变成const和volatile？我怀念Pascal对已声明变量名及其类型的清晰分离(指向指向整数指针数组的指针将是var foo: ^Array[3..4] of ^Integer`)。我想这是C语言中一些有趣的嵌套括号。
"超级猫"(哦，C，只是，对不起C++代码链接，我从C++问题中得到的)都是关于C声明语法的，有一个("纯")类型的部分，后面跟着一个声明符。在"int const *foo, *volatile bar中，类型部分是int const(在*之前停止)，声明者是*foo(表达式*foo表示int const和*volatile bar；从右向左读(cv限定符的好规则)，foo表示const int的指针，bar表示c的不稳定指针。onst int(指针本身是可变的，指向的int是[作为]const访问的)。
@supercat和"指向整数指针数组的指针"(我不知道pascal，不知道[3..4]语法，所以让我们取一个10个元素的数组)：int *(*foo)[10];。它反映了它(将来)作为表达式的使用：*(*foo)[i](与i一个在[0, 10)范围内的整数，即[0, 9]将首先取消引用foo以获取数组，然后访问索引i处的元素(因为后缀[]比前缀*绑定得更紧)，然后取消引用该元素。最终生成一个int(参见ideone.com/jgjijr)。但typedef使其更容易(见ideone.com/o3wb7d)。
我总是完全避免使用多个decl，除了简单的例子"int a，b，c；"。我最近才发现，"int const*p1，*p2"实际上并不意味着我认为它可能做了什么(如上所述)。将继续使用这种形式，因为它只是一种不必要的方式造成混乱。我认为使用这些表单的唯一好理由是，如果您要制作一个编译器遵从性测试套件：—)。
如果在MSVC中对模板void f(t param)，f(ptr)使用const char*const ptr，编译器将告诉您t是char const*并且参数是const char*

为避免混淆，请始终附加const限定符。

1
2
3
4

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应用于后面的内容将更加一致。const int * const p;在第一个const的情况下，它的int数据是常量。在第二个const的情况下，它是p—实际的指针变量，它是常量。把const应用于*是没有意义的，而应用于p则是没有意义的，所以我们应该预先准备const以避免混淆。
@Alla:p与类型没有关系：(const int *const)。不管是好是坏(如果你问我的话)，在C和C++中的const限定符都是后缀：CF const成员函数void foo(int a) const;。声明const int的可能性是例外而不是规则。
@迪皮尔：我不确定const类型限定符"意味着"是后缀。毕竟，您不会应用其他类型限定符，比如volatile和restrict后缀，那么为什么要使用const？至于const成员函数，它不适用于C，而C++中的成员函数确实有说明符和修饰符，包括EDCX1，0，EDCOX1，17，EDCOX1，18，等等。但这些不是类型限定符(尽管对于const，使用的关键字确实是相同的)，因此这些限定符的规则不一定适用于类型声明。
@alla:实际上，成员函数上的const限定了一个类型：隐式this指针的类型，因此也限定了函数的类型。restrict只限定了指针，所以它最终还是属于*的权利，我自己更喜欢volatile后缀。
"编写所有类型限定符，以便修改左侧的内容"-但这并不总是有效。99%的人认为像int unsigned typedef foo;这样的东西不是vali——什么？那真的有效吗？echo"int unsigned typedef foo_t;" | gcc -c -xc - -o /dev/null不生成编译器错误。该死，C型系统非常一致。
我一定想到了static，它是一个存储说明符，而不是类型限定符。
把你的声明写成@diapr所建议的另一个好处是，对于单词const的每一个实例，const-qualified的类型是单词左边的所有内容，const-qualified的对象是右边的所有内容。

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

所以这两个是相同的：

1 2	int const i1; const int i2;

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

这是：

1	int const i3 = (int) 0x12345678;

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

相关讨论

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

参见：

什么是常量指针(与指向常量对象的指针相反)？
C中的Const
C++中const声明的区别
C++常见问题
为什么要更改const char*变量的值？

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

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名称，那么指针将是常量，但指向位置可以更改，否则指针将指向常量位置，指针可以指向其他位置，但指向位置内容不能更改。

相关讨论

Thumb rule of thumb：read the definition from right to left！

法国电力公司

"int不能改变的点(const)"。对编程员来说，这意味着"我不会改变什么是foo点到〔8〕点的价值"。

这将使人残疾。
允许的

法国电力公司

中文"fooCannot Change(const)and Points(*to an int"。对编程员来说，这意味着"我不会改变那个foo的记忆地址"，Refers to the programmer this means"I will not change the memory address that foo.

这是允许的。
将致残。

法国电力公司

《不能改变的》(EDOCX1,11)、《不能改变的》(EDOCX1,11)、《点》(EDOCX1,9)、《不能改变的》(EDOCX1,11)"。这意味着"我不会改变什么foo的价值，我也不会改变foo的地址"。

这将使人残疾。
将致残。

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

1	const char * mychar

和

1	char * const mychar

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

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

存储的值是常量

在*=>指针本身是常量之后

许多答案提供了具体的技术、雷管等，以了解变量宣言的这一具体实例。但是，有一种通用技术可以理解任何宣言：

Clockwise/Spiral Rule

(a)

1	const char *a;

按时钟/螺旋规则a指向常数的特性。意思是常数，但指针可以改变。很好，但很好

(b)

1	char * const a;

按照规则，以一个字符为准。你可以做a[2] = 'c';但你不能做a ="other string";

相关讨论

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

For example:

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

这个密码是完美的。Itself isn't constant.

常数指针：一个常数指针仅能在整个程序中对各数据类型的一个单一变量进行点。我们可以改变指针指向的变量的值。初始化应在ITSELF声明的时间内完成。

句法：

1	datatype *const var;

在这个案件下

ZZU1

指针指向一个固定值：在这个指针中，指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指针指

句法：

或埃多克斯1

在这个案件下

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/* 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
",*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;
}

Const和Const Char*？

指向恒定值

不能改变价值

值恒定指针

地址无法更改

恒定值指针

两者都不能改变。

修正案立即适用于第三方的左侧。这方面唯一的例外是，在没有任何东西属于它的左边时，它立即适用于它的权利。

这些是"恒定指针到恒定指针"的所有等效方式。

法国电力公司
法国电力公司
法国电力公司
char const const *

相关讨论

两条规则

法国电力公司

E.G.

法国电力公司

我想你的意思是常量char*和char*常量。

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

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

还有常量char*const，指针和字符不能更改。

相关讨论

这是一个详细的解释和代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

/*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
",*p);
return 0;
}*/

/*int main()
{
char * const p; // address cannot be changed
char z;
*p = 'c';
//p = &z; // this will not work
printf(" %c
",*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
",*p);
return 0;
}*/

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

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