char * const和const char *之间有什么区别？

Question

有什么区别：

char * const 

和

const char *

Answer 1

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

第一个，指向的值不能改变，但指针可以。第二个，指向的值可以改变，但指针不能（类似于引用）。

还有一个

const char * const

是一个指向常量char的常量指针（因此无法更改它）。

注意：

以下两种形式是等效的：

const char *

和

char const *

C ++标准中描述了其确切原因，但重要的是要注意并避免混淆。我知道几种编码标准更喜欢：

char const

在

const char

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

Answer 2

为避免混淆，请始终追加 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;

Answer 3

const总是修改它前面的东西（在它的左边），除了它是类型声明中的第一个东西，它修改它后面的东西（在它的右边） ）。

所以这两个是相同的：

int const *i1;
const int *i2;

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

此：

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

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

Answer 4

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

另见：

• What are const pointers (as opposed to pointers to const objects)?
• Const in C
• Difference between const declarations in C++
• C++ const question
• Why can I change the values of a const char* variable?

Answer 5

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

Answer 6

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名称，则指针将是常量但指向位置可以更改，否则指针将指向一个恒定的位置和指针可以指向另一个位置，但指向位置内容不能更改。

Answer 7

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

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

Answer 8

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

之间的区别

const char * mychar

和

char * const mychar

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

Answer 9

另一个拇指规则是检查 const 的位置：

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

Answer 10

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

  

Clockwise/Spiral Rule 的

A）

const char *a;

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

B）

char * const a;

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

Answer 11

我认为你的意思是const char *和char * const。

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

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

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

Answer 12

我想指出，使用int const *（或const int *）并不是指向const int变量的指针，但此变量为{{1对于这个特定的指针。

例如：

const

上面的代码编译完全正常。 int var = 10; int const * _p = &var; 指向_p变量，但const本身并不常数。

Answer 13

两条规则

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.

e.g。

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

Answer 14

const修饰符将立即应用于其左侧的术语。唯一的例外是当它的左边没有任何东西时，它就适用于它右边的东西。

这些都是说“常量指针char”的等价方式：

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

Answer 15

char * const和const char *？

1. 指向一个恒定值

const char * p; //无法更改值

1. 指向值的常量指针

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

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

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

Answer 16

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;
}

1. 指向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;
    }

Answer 17

以下是代码

的详细说明

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

Answer 18

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

Answer 19

我记得捷克书中有关C的内容：请阅读以变量开头并向左走的声明。 所以

char * const a;

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

char const * a;

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

奖金：

const char * const a;

您将读为a是指向char类型常量的常量指针。