根据[basic.life]/8，

If, after the lifetime of an object has ended and before the storage which the object occupied is reused or released, a new object is created at the storage location which the original object occupied, a pointer that pointed to the original object, a reference that referred to the original object, or the name of the original object will automatically refer to the new object and, once the lifetime of the new object has started, can be used to manipulate the new object, if:

• the storage for the new object exactly overlays the storage location which the original object occupied, and
• the new object is of the same type as the original object (ignoring the top-level cv-qualifiers), and
• 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, and
• the original object was a most derived object (4.5) of type T and the new object is a most derived object of type T (that is, they are not base class subobjects).

... [ Note: If these conditions are not met, a pointer to the new object can be obtained from a pointer that represents the address of its storage by calling std::launder (21.6). — end note ]

该标准包含一个示例，演示当存在 const 子对象时，“原始对象的名称”无法引用新对象，并且使用该名称会导致 UB。它位于 [intro.object]/2:

Objects can contain other objects, called subobjects. A subobject can be a member subobject (12.2), a base class subobject (Clause 13), or an array element. An object that is not a subobject of any other object is called a complete object. If an object is created in storage associated with a member subobject or array element e (which may or may not be within its lifetime), the created object is a subobject of e’s containing object if:

• the lifetime of e’s containing object has begun and not ended, and
• the storage for the new object exactly overlays the storage location associated with e, and
• the new object is of the same type as e (ignoring cv-qualification).

[ Note: If the subobject contains a reference member or a const subobject, the name of the original subobject cannot be used to access the new object (6.8). — end note ] [ Example:

struct X { const int n; };
union U { X x; float f; };
void tong() {
  U u = {{ 1 }};
  u.f = 5.f;                          // OK, creates new subobject of u (12.3)
  X *p = new (&u.x) X {2};            // OK, creates new subobject of u
  assert(p->n == 2);                  // OK
  assert(*std::launder(&u.x.n) == 2); // OK
  assert(u.x.n == 2);                 // undefined behavior, u.x does not name new subobject
}

然而，在我看来 [basic.life]/8 没有在 u.x.n 定义的行为上给出左值到右值的转换这一事实是无关紧要的，因为它是给定的[expr.ref]/4.2 定义的行为，其中有以下关于类成员访问表达式 E1.E2 的说明:

If E2 is a non-static data member and the type of E1 is “cq1 vq1 X”, and the type of E2 is “cq2 vq2 T”, the expression designates the named member of the object designated by the first expression. ...

我对此的理解是，表达式 u.x 产生一个左值，它引用任何对象 u< 的="">current x 子对象 当前指的是。因为，根据 [intro.object]/2，在 u.x 位置创建新的 X 对象会导致新的 X 对象要真正成为 u 的子对象，对 u.x.n 执行左值到右值的转换应该是明确定义的。

如果我们假设此示例中的 UB 反射(reflect)了标准的意图，看来我们必须将 [basic.life]/8 解读为说 尽管某些表达式可能出现的事实访问新对象(在这种情况下，由于 [expr.ref]/4.2)，如果他们尝试使用原始对象的“名称”进行访问，它们仍然是 UB。 (或者，实际上，编译器可能假定“名称”继续引用原始对象，因此不会重新读取 const 成员的值。)

不过，通常情况下，我不认为 u.x 算作“命名”u 的 X 子对象，因为我认为子对象没有名字。因此，[basic.life]/8 似乎是在说 UB 发生在某些特定情况下，但没有准确解释这些情况是什么。

因此，我的问题是:

1. 我说 [basic.life]/8 导致这个例子包含 UB 而不是简单地没有给它定义的行为，我说得对吗？
2. [basic.life]/8 是否对哪些案例给出了 UB 的精确说明？
3. 是否应该改写标准以更清楚地说明 [basic.life]/8 何时会导致 UB(即，何时需要 std::launder)？

最佳答案

My reading of this is that the expression u.x yields an lvalue referring to the current x subobject of whatever object u currently refers to.

这是真的。您误解的是“当前 x 子对象”的意思。

当您执行 new (&u.x) X {2} 时，会在 u.x 的地址创建一个新对象。然而，标准中没有任何地方说这个对象被命名为 x 或 u.x。是的，它是 u 的子对象，但它没有名称。标准在任何地方都没有说新创建的子对象具有该名称，或与此相关的任何名称。

事实上，如果你说的是真的，[basic.life]/8 和 launder 根本就不需要存在，因为一个对象在另一个对象的覆盖存储中总是可以访问的通过旧对象的名称。

Normally, though, I would not think that u.x counts as "naming" the X subobject of u, because I think that subobjects do not have names.

我不知道你是怎么得出这个结论的，因为你引用了规范中明确规定成员子对象可以有名称的部分:

the expression designates the named member of the object

添加了强调。这清楚地向我暗示成员子对象有一个名称，表达式 u.x 指定该特定成员子对象的名称(不仅仅是该地址中适当类型的任何成员子对象)。

也就是说，正如u特指u声明所声明的对象一样，u.x特指x - 由声明 u 声明的对象的命名成员。

关于c++ - 出于对象替换的目的，对象的 "name"究竟是由什么构成的？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54613240/