Question

我正在学习常量指针而我正在尝试这个

#include<iostream>
using namespace std ;
int main(){
    int a = 10 ; 
    const int *cp  = &a ;               // my constant pointer variable
    cout<<"\nAddress stored in cp = "<<cp ;
    ++cp;
    cout<<"\nAddress stored in cp = "<<cp   ;
}

它增加了cp中存储的地址但根据我到目前为止所理解的，不应该++cp给出错误，因为它是一个始终指向同一地址的常量指针，并且该地址不能被修改。

但是当我更换

时带有const int *cp = &a ;

的

int *const cp = &a ;

它给了我这个 enter image description here

原谅我的无知但是，他们不是想要同样的意思吗？

Answer 1

当您执行int *const cp = &a;时，它表示指向常量cp的整数指针，因此cp无法更改。但是，在您以前的版本中，const int *cp表示指向cp的常量int指针，因此cp指向的值不能更改，但指针本身可以。

通常，人们喜欢从右到左阅读：

const int *cp cp是指向int常量的指针，因此整数不能改变。

int *const cp = &a; cp是一个指向int的常量指针，因此指针不能改变。

Answer 2

const int *cp  = &a ;

cp指向的地址内容是只读的，但指针cp不是

所以，

*cp = value ; //Illegal
++cp ; // Legal

int *const cp = &a ;

指针是只读的，但cp指向的地址内容不是

所以，

*cp = value ; //Legal
++cp ; // Illegal

此外，

const int *const cp  = &a ;

指针和cp指向的地址内容都是只读的

*cp = value ; //Illegal
++cp ; // Illegal

简单声明从右向左阅读

Answer 3

const int *cp1  = &a ; // pointer is variable, pointed to is constant
int *const cp2  = &a ; // pointer is constant, pointed to is variable
const int *const cp3  = &a ; // pointer is constant, pointed to is constant

因此，

cp1++; // possible
*cp1++; // not possible
cp2++; // not possible
*cp2++; // possible
cp3++; // not possible
*cp3++; // not possible

Answer 4

如果它有帮助（并且它可能没有），则以下是同义词，利用允许开场类型在左侧或<上显示const的语言准确性/ em>类型的权利，但在任何其他限定符（如指针或引用）之前：

const int * p; // does NOT require initialization int const * q; // same as above

两者都声明了指向常量int数据的指针，并且在语法上可以互换。

鉴于此：

int * const p = &a; // requires initialization.

声明一个指向int数据的常量指针; 不指向常量int数据的指针。

进一步扩展（实际上合并两者），我们得到：

const int * const p = &a; int const * const p = &a;

这些是同义词。两者都声明了一个指向常量int数据的常量指针。指针和指向的指针都不可修改，并且都需要初始化。

无耻地扯掉图表

从轻微相关的question中，以下是无耻地从我自己（好吧，没那么多的耻辱）中扯下来的。我希望它有助于进一步解释当您将const和*置于声明的不同位置时所发生的差异：

<强>单的间接：

char *p; // p is mutable, *p is mutable const char *p; // p is mutable, *p is const char const *p; // same as above. char *const p; // p is const, *p is mutable, must be initialized. char const *const p; // p is const, *p is const, must be initialized.

双重间接：

char **p; // ptr-to-ptr-to-char // p, *p, and **p are ALL mutable const char **p; // ptr-to-ptr-to-const-char // p and *p are mutable, **p is const char const **p; // same as above char *const *p; // ptr-to-const-ptr-to-char // p is mutable, *p is const, **p is mutable. char **const p; // const-ptr-to-ptr-to-char // p is const, *p is mutable, **p is mutable. // must be initialized. const char **const p; // const-ptr-to-ptr-to-const-char // p is const, *p is mutable, **p is const. // must be initialized. char const **const p; // same as above char const *const *p; // ptr-to-const-ptr-to-const-char // p is mutable, *p is const, **p is const. const char *const *p; // same as above. char *const *const p; // const-ptr-to-const-ptr-to-char // p is const, *p is const, **p is mutable. // must be initialized.

我个人的最爱：

char const *const *const p; // const-ptr-to-const-ptr-to-const-char // everything is const. // must be initialized. const char *const *const p; // same as above

Answer 5

这是我始终建议将const放在int右侧而不是左侧的原因之一。如：

int const *cp;

而不是：

const int *cp;

这样做的好处是，const项目位于const关键字的右侧，而其类型位于左侧。

在上面，* cp（即cp的内容）是const，它的类型是int。如果你写

int * const cp = &foo;

并应用相同的规则，cp为const，const项的类型为int *。当存在多个间接级别时，使用此规则可以更容易地理解正在发生的事情。

int const ** cpp1;
int * const *cpp2;
int ** const cpp3 = &bar;
int const ** const cpp4 = &xyz;

最后一个是指向const的可变指针的const int指针。一个const项的类型为int，而另一个int **类型为const。如果您从未在int的左侧放置{{1}}这个词，那就很容易理解。

const int指针错误

5 个答案: