C++ - 为什么 const 函数不强制成员指针上的 const-ness？

Question

Const 函数似乎并不关心您是否将成员指针解引用为非 const 引用。也可以返回非常量成员指针。但是，不允许返回具有值类型的数据成员的引用或地址。

为什么？

class Class
{
public:
unsigned int& value2(void) const
{
    *m_ptr = 10;
    return *m_ptr; 
    //Why?
}

unsigned int* value3(void) const
{
    return m_ptr; //Why?
}

private:
unsigned int* m_ptr;
};

Answer 1

编辑：

关于您的代码：您永远不会真正更改成员或返回对它的引用。

unsigned int& value2(void) const
{
    *m_ptr = 10;
    return *m_ptr; 
                //Why?
}
//returns the value your member points to, not your member

unsigned int* value3(void) const
{
    return m_ptr; //Why?
}
//returns a copy of your member

我在 sn-p 中发布的版本是不允许的。

例如：

struct A
{
   int * x;
   int& getX() const { return *x; }
   int* getX1() const { return x; }
   int*& getX2() const { return x; } //error here
};

只有最后一个方法会返回错误，因为：

• 第一个返回值，它不是 const。指针是 const。
• 第二个返回指针按值，又没问题
• 第三个实际上是通过引用返回成员，这就是为什么它是非法的

Answer 2

它确实强制了成员指针的常量；只是不是指针指向的常量！

为了证明，以下是非法的：

class foo
{
public:
    void bar() const
    {
        p = 0;
    }

private:
    int* p;
};

会给你一个编译错误，例如assignment of member 'foo::p' in read-only object。

基本上在一个const成员函数中，T类型的成员变量被认为是T const，如果T是指针类型，比如说int*，这就产生int* const，意思是“const指针to int"，即指针不可修改，但取消引用它会产生int&，而不是const int&。如果T*被认为是T const *或T const * const，那就另当别论了。

至于基本原理，仅仅因为指针是对象状态的一部分，并不意味着指针指向的对象是（尽管它可以是）。更改指针指向的内容不会改变对象的可想象的状态。

Answer 3

我想我不明白你的问题。我尝试了以下方法：

class X {
  int x;
  int* foo() const {
    return &x;
  }
};

int main() {
}

它无法正确编译并显示消息“错误：从‘const int*’到‘int*’的无效转换”。

您的问题是否与上述示例相符？如果不一样，能否给个示例代码？

---

鉴于对您的问题的更详细解释，现在我理解您了。 成员指针 unsigned int* m_ptr 在 const 成员函数中是常量。但指针所指的内容——不是。该内容超出了您的对象的范围，并且 const 函数与它无关。

在您的value2 函数中，您将无法更改指针本身。就是这样。

Answer 4

我想这就是困扰你的原因。

struct Example
{
   int * p;
   Example(): i(new int) {}
   ~Example() { delete p; }
};

const Example e;
*(e.i) = 7 

这没关系，因为指针没有改变，它仍然指向内存中的同一个点。

但是这并不好，因为它会改变指针：

e.i = new int(4);

如果你希望这两个都被禁止，你应该提供一个访问器函数。

class Example
{
  public:
    int * i() { return i_; }
    const int * i() const { return i_; }
  protected: 
    int i_;
};

现在我们有了：

Example e1;
*( e.i() )=7; //OK

const Example e2;
*( e.i() )=7; // FAILS TO COMPILE.

Answer 5

常量函数确实尊重其成员变量的常量性。当您返回一个指向函数的指针时，您返回一个指针，您返回该指针的副本，出于同样的原因，您可以在 const 方法中返回对象的副本。然而，指针所指向的内容不会被视为 const，因此您甚至可以在 const 函数中对其进行修改。

例如：

    struct A
    {
        int n;
        int * p;
        int & f1() const {return n;} //not allowed
        int f2() const {return n;} //allowed
        int * f3() const {return p;} //allowed
        int *& f4() const {return p;} //not allowed
        int & f5() const {return *p;} //allowed, because what p points to is not const
    };