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

时间:2009-05-20 22:16:23

标签: c pointers const

有什么区别:

char * const 

const char *

19 个答案:

答案 0 :(得分:321)

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

第一个,指向的值不能改变,但指针可以。第二个,指向的值可以改变,但指针不能(类似于引用)。

还有一个

const char * const

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

注意:

以下两种形式是等效的:

const char *

char const *

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

char const

const char

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

答案 1 :(得分:91)

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

答案 2 :(得分:38)

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

所以这两个是相同的:

int const *i1;
const int *i2;

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

此:

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

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

答案 3 :(得分:21)

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

另见:

答案 4 :(得分:14)

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

答案 5 :(得分:8)

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

答案 6 :(得分: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;无效。

答案 7 :(得分:3)

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

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

答案 8 :(得分:3)

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

之间的区别
const char * mychar

char * const mychar

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

答案 9 :(得分:2)

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

  

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

答案 10 :(得分:1)

以下是代码

的详细说明
/*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;
}*/

答案 11 :(得分:1)

  1. 常量指针:在整个程序期间,常量指针只能指向相应数据类型的单个变量。我们可以更改指针指向的变量的值。初始化应在声明本身期间完成。
  2. 语法:

    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值的指针:在此指针中可以指向相应类型的任意数量的变量,但我们无法更改指针在该特定时间指向的对象的值。
    2. 语法:

      const datatype *vardatatype 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;
          }
      

答案 12 :(得分:1)

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

例如:

const

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

答案 13 :(得分:1)

char * const和const char *?

  1. 指向一个恒定值
  2. const char * p; //无法更改值

    1. 指向值的常量指针
    2. char * const p; //地址无法更改

      1. 指向常量值的常量指针
      2. const char * const p; //两者都无法更改。

答案 14 :(得分:1)

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

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

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

答案 15 :(得分:1)

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

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

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

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

答案 16 :(得分:1)

两条规则

  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.
  3. 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.

答案 17 :(得分:0)

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

char * const a;

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

char const * a;

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

奖金:

const char * const a;

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

答案 18 :(得分: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’
}