这段代码是否颠覆了 C++ 类型系统？

Question

我了解在 C++ 中使用 const 方法意味着对象通过该方法是只读的，但它仍可能会更改。

但是，这段代码显然通过const 引用（即通过const 方法）更改了对象。

这段代码在 C++ 中合法吗？

如果是这样：它是否破坏了类型系统的const-ness？为什么/为什么不？

如果不是：为什么不呢？

注意 1：我已经对示例进行了一些编辑，因此答案可能是指较旧的示例。

编辑 2：显然你甚至不需要 C++11，所以我删除了该依赖项。

#include <iostream>

using namespace std;

struct DoBadThings { int *p; void oops() const { ++*p; } };

struct BreakConst
{
    int n;
    DoBadThings bad;
    BreakConst() { n = 0; bad.p = &n; } 
    void oops() const { bad.oops(); }  // can't change itself... or can it?
};

int main()
{
    const BreakConst bc;
    cout << bc.n << endl;   // 0
    bc.oops();              // O:)
    cout << bc.n << endl;   // 1

    return 0;
}

更新：

我已将 lambda 迁移到构造函数的初始化列表，因为这样做允许我随后说 const BreakConst bc;，这 -- 因为 bc 本身 现在是 const（而不仅仅是指针) -- 似乎暗示 (by Stroustrup) 在构造之后以任何方式修改 bc 会导致未定义的行为，即使构造函数和调用者在没有看到彼此定义的情况下无法知道这一点。

Answer 1

oops() 方法不允许改变对象的常量。此外，它不这样做。它是你的匿名函数。这个匿名函数不在对象的上下文中，而是在允许修改对象的 main() 方法的上下文中。

您的匿名函数不会更改 oops() 的 this 指针（它被定义为 const，因此无法更改），也绝不会从此 this 指针派生一些非常量变量。它本身没有任何this-pointer。它只是忽略 this 指针并更改主上下文的 bc 变量（它作为参数传递给您的闭包）。此变量不是 const，因此可以更改。您还可以传递任何匿名函数来更改完全不相关的对象。这个函数不知道，它改变了存储它的对象。

如果您将其声明为

const BreakConst bc = ...

那么主函数也将其作为 const 对象处理，无法更改。

编辑： 换句话说： const 属性绑定到访问对象的具体左值（引用）。它不绑定到对象本身。

Answer 2

您的代码是正确的，因为您没有使用 const 引用来修改对象。 lambda 函数使用完全不同的引用，它恰好指向同一个对象。

一般来说，这种情况不会颠覆类型系统，因为C++中的类型系统并没有正式保证不能修改const对象或const引用。然而，修改 const 对象是未定义的行为。

来自 [7.1.6.1] cv 限定符：

指向 cv 限定类型的指针或引用不需要实际指向 或引用一个 cv 限定的对象，但它被当作是这样处理；一种 const 限定的访问路径不能用于修改对象，即使 引用的对象是非常量对象，可以通过以下方式修改 其他一些访问路径。

除了可以修改任何声明为可变的类成员（7.1.1）， 任何在 const 对象的生命周期 (3.8) 中修改其结果的尝试 在未定义的行为中。

Answer 3

我已经看到了类似的东西。基本上，您调用一个成本函数，该函数调用其他东西来修改对象而不知道它。

也考虑一下：

#include <iostream>
using namespace std;

class B;

class A
{
    friend class B;
    B* pb;
    int val;
public:
    A(B& b); 
    void callinc() const;
    friend ostream& operator<<(ostream& s, const A& a)
    { return s << "A value is " << a.val; }
};

class B
{
    friend class A;
    A* pa;
public:
    void incval() const { ++pa->val; }
};

inline A::A(B& b) :pb(&b), val() { pb->pa = this; }
inline void A::callinc() const { pb->incval(); }


int main()
{
    B b;
    const A a(b);  // EDIT: WAS `A a(b)`
    cout << a << endl;
    a.callinc();
    cout << a << endl;
}

这不是 C++11，但也是一样的： 关键是 const 不是传递的。

callinc() 不会改变自己 a 和 incval 不会改变 b。 请注意，在 main 中，您甚至可以声明 const A a(b); 而不是 A a(b);，并且所有内容都可以编译。

这在几十年内有效，在您的示例中，您只是在做同样的事情：只需将 B 类替换为 lambda。

编辑

更改了 main() 以反映评论。

Answer 4

问题是逻辑 const 与按位 const 之一。编译器 对程序的逻辑含义一无所知，并且 仅强制执行按位 const。由你来实现逻辑常量。 这意味着在您展示的情况下，如果指向的内存是 逻辑上是对象的一部分，您应该避免在 const 函数，即使编译器允许你（因为它不是一部分 对象的按位图像）。这也可能意味着，如果部分 对象的按位图像不是逻辑值的一部分 对象（例如嵌入的引用计数或缓存的值），你可以做到 mutable，或者甚至抛弃 const，如果你修改它而不 修改对象的逻辑值。

Answer 5

const 功能仅有助于防止意外误用。它并非旨在防止专用软件黑客攻击。它与私有成员和受保护成员相同，总是有人可以获取对象的地址并沿内存递增以访问类内部，没有办法阻止它。

所以，是的，你可以绕过 const。如果没有别的，您可以简单地在内存级别更改对象，但这并不意味着 const 被破坏。