c++ - 用相同类型的对象覆盖对象

Question

下面的定义是否明确？

#include <iostream>
#include <string.h>

using namespace std;

struct Const {
    const int i; 
    Const (int i) : i(i) {}
    int get0() { return 0; } // best accessor ever!
};

int main() {
    Const *q,*p = new Const(1);
    new (p) Const(2);
    memcpy (&q, &p, sizeof p);
    cout << q->i;
    return 0;
}

请注意，在构造第二个 Const 之后，p 并没有在语义上(故意？)指向新对象，并且第一个已经消失，所以它是可用的"作为 void*”。但是第二个对象是在完全相同的地址构造的，因此 p 的位模式表示新对象的地址。

评论

new (p) Const(2) 删除存储在 p 的旧对象，因此指针不再有效，除非指向存储的指针 (void*)。

我想恢复 p 的值作为 Const*。

评论 2

在 p->~Const() 或 memset (p, 0, sizeof *p) 之后很明显 p 确实不指向有效对象，因此 p 只能用作指向存储(void* 或 char*)的指针，例如重建另一个对象。那时 p->get0() 是不允许的。

这里旧对象的拆除是由新对象的构造函数完成的，但我认为这没有什么区别。

我的直觉是:无论如何，旧对象都没有了，p指向旧对象，而不是新对象。

我正在寻找基于标准的确认或反驳。

另见

我在 C 和 C++ 中问过关于指针的基本相同的问题:

• Dereferencing an out of bound pointer that contains the address of an object (array of array)
• Is memcpy of a pointer the same as assignment?
• Are pointer variables just integers with some operators or are they "mystical"?

请在回答“这很荒谬”之前阅读这些讨论。

Answer 1

(将社区维基纳入 dyp 对 3.8/7 的评论是非常重要的；虽然我之前的分析是正确的，但我自己也忽略了 3.8/7，所以我也会对损坏的代码说很多相同的话)

Const *q,*p = new Const(1);
new (p) Const(2);

new(p) Const(2); 行覆盖了用 Const(1) 构造的对象。

memcpy (&q, &p, sizeof p);

这等同于q = p;。

cout << q->i;

这将访问 q->i 成员，它将是 2。

比较值得注意的是:

• std::memcpy 是一种将 p 分配给 q 的丑陋方式……尽管在 3.9/3 下它是合法的:

For any trivially copyable type T, if two pointers to T point to distinct T objects obj1 and obj2, where neither obj1 nor obj2 is a base-class subobject, if the underlying bytes (1.7) making up obj1 are copied into obj2, obj2 shall subsequently hold the same value as obj1. [ Example:

T* t1p;
T* t2p;
// provided that t2p points to an initialized object ...
std::memcpy(t1p, t2p, sizeof(T));
// at this point, every subobject of trivially copyable type in *t1p contains
// the same value as the corresponding subobject in *t2p

• 只要程序不依赖于 Const(1) 的副作用，就允许使用 Const(2) 覆盖旧的 Const(1) 对象前者的析构函数，它不是。

• (正如 dyp 在下面的评论中指出的那样)根据 3.8/7 的第三点，使用 p 持续访问 Const(2) 对象是非法的:

pointer that pointed to the original object [...] can be used to manipulate the new object, if...

• the type of the original object is not const-qualified, and, if a class type, does not contain any non-static data member whose type is const-qualified or a reference type ...

• 使用 q - 而不是 p - 访问 i 可能是必要的，以避免基于 i 的假定知识进行编译器优化。

至于你的评论:

Note that after construction of second Const, p doesn't semantically (intentionally?) points to new object, and the first is gone, so it is usable "as a void*".

如果您在 p 中包含的地址放置新对象，p 肯定会指向新创建的对象，而且是有意为之，但它不能不能像上面那样在 3.8/7 下操作该对象。

假设您似乎有一个 C++ 中未定义的“语义指向”的概念，那么该部分语句的真实性就在您自己的脑海中。

'在构造第二个 Const 之后，p...可用作“void*”没有意义……它没有比以前更有用了。

But the second object is constructed at the exact same address, so the bit pattern of p represents the address of the new object.

当然，但是您的评论表明您认为“位模式”在某种程度上不同于指针的值，因为它适用于使用 = 进行赋值，这是不正确的.

new (p) Const(2) erase the old object stored at p, so the pointer is not valid anymore, except as a pointer to storage (void*).

“删除”是一个奇怪的术语......覆盖会更有意义。正如 dyp 在上面指出和解释的那样，3.8/7 说你不应该在放置 new 之后“操纵”对象 p 指向的对象，但是指针的值和类型不受 placmeent new 的影响。就像您可以使用指向任何类型的指针调用 f(void*) 一样，placement-new 不需要知道或关心 的类型>p 表达式。

After either p->~Const() or memset (p, 0, sizeof *p) it is clear that p does not point to a valid object, so p can only be used as pointer to storage (void* or char*), for example to reconstruct another object. At that point p->get0() is not allowed.

大部分是正确的，如果“p can only be used”你指的是当时 p 的值而不是指针本身(可以是当然也被分配到)。而且你试图对 void*/char* 事情有点太聪明了 - p 仍然是 Const*，即使它仅由不关心指针类型的 placement new 使用。

"I want to recover the value of p as a Const*."

p 的值在第一次初始化后没有改变。 placement-new 使用该值 - 它不会修改它。没有什么可以恢复，因为什么都没有丢失。也就是说，dyp 强调不需要使用 p 来操作对象，因此虽然值没有丢失，但它也不能直接按需要使用。