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

Question

有什么区别：

char * const 

和

const char *

Answer 1

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

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

还有一个

const char * const

which是一个指向常量char的常量指针（所以它的任何内容都不能改变）。

注意：

以下两种形式是等效的：

const char *

and

char const *

其确切原因在 C++ 标准中进行了描述，但请务必注意并避免混淆。 我知道几个编码标准更喜欢：

char const

over

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 值，但不能更改i3 指向的地址。

Answer 4

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

---

const int *foo;

表示“foo 指向 (*) 一个无法更改的 int (常量）”。
对于程序员来说，这意味着“我不会更改 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) 并将 (*) 指向 < code>int 无法更改 (const)”。
对于程序员来说，这意味着“我不会更改 foo 指向的值，也不会更改 foo 的地址 指的是“。

• *foo = 123; 或 foo[0] = 123; 无效。
• foo = &bar; 无效。

Answer 5

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

Answer 6

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

另请参阅：

• 什么是 const 指针（而不是指向 const 对象的指针）？
• C 中的 const
• C++ 中 const 声明之间的差异
• C++ const 问题
• 为什么我可以更改 const char* 变量的值？

Answer 7

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 一起使用，那么指针将是常量，但指向的位置可以更改，否则指针将指向常量位置，并且指针可以指向另一个位置，但是指向位置内容无法更改。

Answer 8

另一个经验法则是检查 const 位于何处：

1. before * => 值存储为常数
2. *后 => 指针本身是常量

Answer 9

第一个是语法错误。 之间的区别

const char * mychar

也许您的意思是和

char * const mychar

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

Answer 10

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

顺时针/螺旋规则

A)

const char *a;

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

B)

char * const a;

根据规则， a< /code> 是指向字符的 const 指针。 即您可以执行 a[2] = 'c'; 但不能执行 a = "other string";

Answer 11

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

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

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

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

Answer 12

这里有详细的代码解释

/*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 13

char * const 和 const char *?

1. 指向常量值

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

2. 指向值的常量指针

char * const p ; // 地址不能更改

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

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

Answer 14

// 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 15

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

Answer 16

const 修饰符应用于紧邻其左侧的术语。 唯一的例外是，当其左侧没有任何内容时，它适用于紧邻其右侧的内容。

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

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

Answer 17

两条规则

1. 如果 const 位于 char 和 * 之间，则影响左边的。
2. 如果 const 不在 char 和 * 之间，则影响最近的一个。

例如

1. 字符常量*。 这是一个指向常量 char 的指针。
2. char * const。 这是一个指向字符的常量指针。

Answer 18

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

例如：

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

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

Answer 19

我记得在关于 C 的捷克书上：阅读从变量开始并向左走的声明。
因此，

char * const a;

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

char const * a;

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

您

const char * const a;

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