堆分配的 const 对象与非 const 对象有何不同？

发布于 2024-12-19 08:08:56 字数 637 浏览 4 评论 0原文

const Class* object = new const Class();
const_cast<Class*>( object )->NonConstMethod(); // UB

这样尝试写入对象将是 UB。

我不明白这样的对象与未声明 const 的堆分配对象有何不同：

const Class* object = new Class();

我的意思是，当我在堆栈上分配一个对象时，它会进入自动存储 em> 这是特定于实现的，因此可能有一些特定于实现的方法，允许以某种特殊的方式分配 const 对象，当我写入对象时，这会产生 UB。

然而，每当我使用 new 时，编译器都需要发出operator new() 函数调用，并且该函数不可能做任何不同的事情 - 它只是以统一的方式分配内存不管我的代码中是否有 const 。

const 堆分配对象与非 const 对象有何不同？如果我尝试修改它，未定义的行为如何可能发生？

原文

In C++ it is possible to allocate a const object on heap:

const Class* object = new const Class();
const_cast<Class*>( object )->NonConstMethod(); // UB

so that attempt to write into an object will be UB.

I don't get how such an object will be different from a heap-allocated object that is not declared const:

const Class* object = new Class();

I mean when I allocate an object on stack it goes to automatic storage which is implementation-specific and so there might be some implementation-specific means that would allow allocating const objects in some special way that would yield UB when I write to an object.

Yet whenever I use new the compiler is required to emit operator new() function invokation and that function can't possibly do anything different - it just allocates memory in a uniform manner regardless of whether there was const in my code.

How is a const heap-allocated object different from a non-const one and how is undefined behavior possible if I try to modify it?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

情魔剑神 2024-12-26 08:08:57

它取决于实现，但可能没有任何不同。它可以被修改。但编译器会拒绝尝试这样做的代码。

const 更多的是拒绝编译修改对象的代码，而不是实际上使其无法以任何方式修改。这是给编译器的一条注释，上面写着“不要让我尝试错误地更改它”。

回复收藏 0 原文

泪痕残 2024-12-26 08:08:57

const 对象和非 const 对象之间没有任何区别。您的示例中也没有未定义的行为。你期望什么UB？通过调用非常量函数，您将获得您期望的行为。

让我提醒您，某些字段可能被声明为可变的，以便对象整体上不是 const。更不用说你甚至可以以编译器不知道你的成员函数的具体非常量的方式滥用：

class A {
public:
    A() : value_(0) {}
    void abuse() const { const_cast<A*>(this)->value_  = 1 ; }
    int value_;
    };

void test() {
    const A a;
    std::cout << a.value_ << std::endl;
    a.abuse() ;
    std::cout << a.value_ << std::endl;
    }

我们可能会得到 UB。

There is no difference whatsoever between const and non-const object. There is no undefined behaviour neither in your exemple. What UB do you expect ? By calling the non-const function, you'll get the behaviour you expect from it.

Let me remind you that some fields may be declared mutable so that the object is not const as a whole. Not mentioning that you can even abuse in syuch a way that the compiler will not be aware of concrete non-constness of your member function:

class A {
public:
    A() : value_(0) {}
    void abuse() const { const_cast<A*>(this)->value_  = 1 ; }
    int value_;
    };

void test() {
    const A a;
    std::cout << a.value_ << std::endl;
    a.abuse() ;
    std::cout << a.value_ << std::endl;
    }

There we maybe get UB.

回复收藏 0 原文