关于“int const *p”和“const int *p”

Question

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
    int i1 = 0;
    int i2 = 10;

    const int *p = &i1;
    int const *p2 = &i1;
    const int const *p3 = &i1;

    p = &i2;
    p2 = &i2;
    p3 = &i2;

    cout << *p << endl
        << *p2 <<endl
        << *p3 <<endl;
    return 0;
}

该代码可以用VC6.0和VC2010编译。 但我有以下问题：

const int *p = &i1;

这意味着“p”点不能修改，但是p不能修改，对吗？ 所以

p = &i2;

这条线可以遵守，是吗？

这句话：

int const *p2 = &i1;

在我看来，这意味着 p2 不能修改，而 p2 的哪些点可以更改，我对吗？ 为什么

p2 = &i2;

可以编译吗？

关于这一行：

const int const *p3 = &i1;

p3 = &i2;

哦，上帝……我疯了。我不知道为什么这一行可以编译而没有错误...... 有谁可以帮助我吗？

另一个让我困惑的代码在这里：

class Coo2    
{      
 public:     

 Coo2() : p(new int(0)) {}    

 ~Coo2() {delete p;}    


    int const * getP() const   
    {      
         *p = 1;         
         return this->p;      
    }      

 private:    
      int* p;    
};   

为什么这段代码可以编译？ 在

int const * getP() const

我已经更改了值或 *p ！

Answer 1

这里我们考虑 4 种类型的指针声明：

1. int * w;
   这意味着 w 是一个指向整数类型值的指针。我们可以修改指针及其内容。如果我们在声明时初始化 w 如下：
   int * w = &a;
   那么，以下两个操作都是可行的：
   w = &b;（真）
   *w = 1;（真）

2. int * const x;
   这意味着x是一个指向整数类型值的常量指针。如果我们在如下声明时初始化 x：
   int * const x = &a;
   那么，我们不能这样做：x = &b;(错误)，因为 x 是一个常量指针，无法修改。
   但是，可以这样做：*x = 1;(true)，因为 x 的内容不是常量。

3. int const * y; //两者意思相同
   const int * y;
   这意味着 y 是一个指向常量整数值的指针。如果我们在如下声明时初始化 y：
   int const * y = &a;
   然后，可以执行：y=&b;(true)，因为 y 是一个可以指向任何地方的非常量指针。
   但是，我们不能这样做：*y=1;（错误），因为 y 指向的变量是常量变量，无法修改。

4. int const * const z; //两者意思相同
   const int * const z;
   这意味着 z 是一个常量指针，指向一个常量整数值。如果我们在如下声明时初始化 z：
   int const * const z = &a;
   因此，以下操作均不可行：
   z = &b;（错误）
*z = 1;(错误)

Answer 2

借助指针，您实际上可以做两件事。

1. 您可以更改它指向的数据，但不能指向不同的内存位置。
2. 您可以将其指向不同的内存位置，但无法更改其指向的数据。

现在，当您说 int const* ptr 或 int const* ptr 时，它属于第一类。和-To一样

const int num = 5; // Both mean the same.
int const num = 5; 

，实际上不能改变到不同的位置，即指向常量位置但可以修改数据，语义应该是int* const。由于指针的内容是常量，因此应在声明时对其进行初始化。

int num = 5;

int* const ptr; // Wrong
ptr = # // Wrong

int* const ptr = #
*ptr = 100;

然而，还有第三种。指向常量位置的常量指针，它既不能指向不同的内存位置，也不能更改它所指向的数据。 （即 const int* const ）

现在回答问题，前两个可以编译，因为它们没有指向常量位置。因此，它们也可以在后期进行修改。

const int const *p3 = &i1;
p3 = &i2;  // Wrong

在上面的代码片段中，p3 是指向常量位置的常量指针。所以，它不能被修改。

成员函数末尾的 const 表示它不会改变对象的状态。当您说 *p = 1; 时，您并没有更改对象的状态。 p 仍然指向相同的内存位置。这是不允许这样做的 -

int const * Coo2::getP() const   
{      
     *p = 1;   // State of `p` is still not modified.
     p = new int ; // Error: Changing the memory location to which p points.
                   //        This is what changing the state of object mean and       
                   //        is not allowed because of `const` keyword at the end of function
     return this->p;      
}

希望，现在你明白为什么程序会编译:)

Answer 3

int const * p; 和 const int * p 是相同的。当 const 出现在 * 之后时，
表达式的语义发生变化。

我知道，这很疯狂。

Answer 4

const int *p = &i1;
int const *p2 = &i1;

它们都声明指向 const 数据的非常量指针。

也就是说，使用p，您无法更改它指向的数据。但是，您可以更改指针本身，例如，通过指定为合法的 p = &i2 。但是*p = 87987是非法的，因为p指向的数据是const！

--

int * const p = &i1;

这声明了指向非常量数据的 const 指针。也就是说，p=&i2 是非法的，但 *p = 98789 是合法的。

--

const int * const p = &i1;

这声明了指向 const 数据的 const 指针。也就是说，现在 p=&i2 和 *p=87897 都是非法的。

Answer 5

两者完全一样。重要的是限定符相对于星号 (*) 的位置：

int const *p; // normal pointer to const int
const int *p; // ditto

int *const p; // const pointer to normal int (rarely useful)

int const * const p; // const pointer to const int

Answer 6

这是一个指向常量的指针：

  const int* p;

以下语句是非法的，因为它试图更改
常量的值：

  *p = 3;

但是这个是合法的，因为指针本身不是常量：

  p = &x;

另一方面，这个声明显示了一个指向变量的常量指针。

  int* const p;

在这种情况下，以下语句是合法的，因为可以更改变量：

  *p = 3;

但这一条语句不是合法的，因为它试图更改常量的值。

  p = &x;

参考链接：http://faculty.cs.niu.edu/ ~freedman/241/const-ptrs.txt

Answer 7

不，* 之前的 const 关键字表示您指向的变量是“const”变量，只是它不能被修改。

1. 如果您想要一个无法重新分配的指针，那么您需要将其声明为 Foo* const p = &bar;
2. 如果您想要一个指向可以'const'对象的指针不能重新分配 将其声明为 const Foo* const p = &bar

将 const int* foo 指针分配给 指针是完全可以的>const int* const bar 就像将 int 的值分配给 const int 一样。以同样的方式思考它。

Answer 8

int const * 与 const int * 相同

Answer 9

简洁地说；读/写 int 和 int 的每个组合指针;

int main() {

  int a,b;

  int* w;                       // read/write int, read/write pointer
  w= &b;                        // good
  *w= 1;                        // good

  int* const x = &a;            // read only pointer, read/write int 
  // x = &b;                    // compilation error
  *x = 0;                       // good

  int const * y;                // read/write ptr, read only int 
  const int * y2;               // "    "    "
  y = &a;                       // good
  // *y = 0;                    // compilation error
  y2 = &a;                      // good
  // *y2 = 0;                   // compilation error

  int const * const z = &a;     // read only ptr and read only int 
  const int * const z2 = &b;    // "    "   "   "   
  // *z = 0;                    // compilation error
  // z = &a;                    // compilation error
  // *z2 = 0;                   // compilation error
  // z2 = &a;                   // compilation error

}