在初始化内存上使用 placement new 是否合法？
Is it legal to use placement new on initialised memory?
我正在探索在 C++ 中实现真正（部分）不可变数据结构的可能性。由于C++似乎不区分变量和变量存储的对象，所以真正替换对象（没有赋值操作！）的唯一方法是使用placement new:
auto var = Immutable(state0);
// the following is illegal as it requires assignment to
// an immutable object
var = Immutable(state1);
// however, the following would work as it constructs a new object
// in place of the old one
new (&var) Immutable(state1);
假设 运行 没有非平凡的析构函数，这在 C++ 中是合法的还是我应该期待未定义的行为？如果它依赖于标准，那是 minimal/maximal 标准版本，我可以期望它在其中工作？
附录：因为似乎人们在 2019 年仍在阅读此内容，所以请快速注意一下——这种模式实际上在现代 (post17) C++ 中是合法的，使用 std::launder().
来自C++标准草案N4296：
3.8 Object lifetime
[...]
The lifetime of an object of type T ends when:
(1.3) — if T is a class
type with a non-trivial destructor (12.4), the destructor call starts,
or
(1.4) — the storage which the object occupies is reused or
released.
[...]
4 A program may end the lifetime of any object by
reusing the storage which the object occupies or by explicitly calling
the destructor for an object of a class type with a non-trivial
destructor. For an object of a class type with a non-trivial
destructor, the program is not required to call the destructor
explicitly before the storage which the object occupies is reused or
released; however, if there is no explicit call to the destructor or
if a delete-expression (5.3.5) is not used to release the storage, the
destructor shall not be implicitly called and any program that depends
on the side effects produced by the destructor has undefined behavior.
所以是的，您可以通过重用其内存来结束对象的生命周期，即使是具有非平凡析构函数的对象，只要您不依赖于析构函数调用的副作用。
这适用于对象的非常量实例，例如 struct ImmutableBounds { const void* start; const void* end; }
你实际上问了 3 个不同的问题:)
1.不变性合约
只是 - 合同，而不是语言结构。
例如，在 Java 中，String class 的实例是不可变的。但这意味着 class 的所有方法都被设计为 return class 的新实例，而不是修改实例。
因此，如果您想将 Java 的 String 变成可变对象，则无法访问其源代码。
同样适用于用 C++ 或任何其他语言编写的 classes。您可以选择创建 wrapper（或使用代理模式），仅此而已。
2。使用放置构造函数并分配到已初始化的内存中。
这实际上是创建它们的初衷。
放置构造函数最常见的用例是 内存池 - 您预先分配一个大内存缓冲区，然后将您的东西分配到其中。
所以是的 - 这是合法的，没有人会介意。
3。使用放置分配器覆盖 class 实例的内容。
不要那样做。
有一种特殊的结构可以处理这种类型的操作，它被称为复制构造函数。
您写的内容在技术上是合法的，但几乎肯定没有用。
假设
struct Immutable {
const int x;
Immutable(int val):x(val) {}
};
对于我们真正简单的不可变类型。
auto var = Immutable(0);
::new (&var) Immutable(1);
这是完全合法的。
而且没用，因为您不能使用 var 来指代放置 new 之后存储在其中的 Immutable(1) 的状态。任何此类访问都是未定义的行为。
你可以这样做：
auto var = Immutable(0);
auto* pvar1 = ::new (&var) Immutable(1);
并且访问 *pvar1 是合法的。你甚至可以这样做：
auto var = Immutable(0);
auto& var1 = *(::new (&var) Immutable(1));
但在任何情况下您都不得在放置新内容后引用 var。
C++ 中的实际 const 数据是对编译器的承诺，您永远不会更改该值。这是与对 const 的引用或指向 const 的指针的比较，这只是建议您不要修改数据。
const 声明的结构成员是 "actually const"。编译器会假定它们从未被修改，也不会费心去证明它。
您在旧实例生效的地方创建新实例违反了此假设。
您可以这样做，但是您不能使用旧名称或指针 来引用它。 C++ 让你搬起石头砸自己的脚。往前走，我们敢。
这就是为什么这种技术是合法的，但几乎完全没有用。具有静态单一分配的优秀优化器已经知道您将在此时停止使用 var，并创建
auto var1 = Immutable(1);
它可以很好地重用存储空间。
在另一个变量之上校准新的位置通常是定义的行为。这通常是一个坏主意，而且 脆弱 。
这样做会结束旧对象的生命周期而不调用析构函数。如果某些特定假设成立（完全相同的类型，没有 const 问题），旧对象的引用和指针以及名称指的是新对象。
修改声明为 const 的数据，或包含 const 字段的 class，会导致引脚掉落时出现未定义的行为。这包括结束声明为 const 的自动存储字段的生命周期并在该位置创建一个新对象。旧名称、指针和引用不能安全使用。
[Basic.life3.8]/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:
(8.1)
the storage for the new object exactly overlays the storage location which the original object occupied,
and
(8.2)
the new object is of the same type as the original object (ignoring the top-level cv-qualifiers), and
(8.3)
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
(8.4)
the original object was a most derived object (1.8) of type
T
and the new object is a most derived
object of type
T
(that is, they are not base class subobjects).
简而言之，如果您的不变性是通过 const 成员编码的，使用旧名称 或 指向旧内容的指针是 未定义的行为.
您可以使用 placement new 的 return 值来引用新对象，没有别的。
异常的可能性使得阻止执行未定义行为或必须立即退出的代码变得极其困难。
如果您需要引用语义，请使用指向 const 对象的智能指针或可选的 const 对象。两者都处理对象生命周期。第一个需要堆分配但允许移动（和可能的共享引用），第二个允许自动存储。两者都将手动对象生命周期管理从业务逻辑中移出。现在，两者都可以为空，但是无论如何手动都很难避免这种情况。
还考虑写时复制指针，这些指针允许逻辑 const 数据具有突变以提高效率。
我正在探索在 C++ 中实现真正（部分）不可变数据结构的可能性。由于C++似乎不区分变量和变量存储的对象，所以真正替换对象（没有赋值操作！）的唯一方法是使用placement new:
auto var = Immutable(state0);
// the following is illegal as it requires assignment to
// an immutable object
var = Immutable(state1);
// however, the following would work as it constructs a new object
// in place of the old one
new (&var) Immutable(state1);
假设 运行 没有非平凡的析构函数，这在 C++ 中是合法的还是我应该期待未定义的行为？如果它依赖于标准，那是 minimal/maximal 标准版本，我可以期望它在其中工作？
附录：因为似乎人们在 2019 年仍在阅读此内容，所以请快速注意一下——这种模式实际上在现代 (post17) C++ 中是合法的，使用 std::launder().
来自C++标准草案N4296：
3.8 Object lifetime
[...]
The lifetime of an object of type T ends when:
(1.3) — if T is a class type with a non-trivial destructor (12.4), the destructor call starts, or
(1.4) — the storage which the object occupies is reused or released.
[...]
4 A program may end the lifetime of any object by reusing the storage which the object occupies or by explicitly calling the destructor for an object of a class type with a non-trivial destructor. For an object of a class type with a non-trivial destructor, the program is not required to call the destructor explicitly before the storage which the object occupies is reused or released; however, if there is no explicit call to the destructor or if a delete-expression (5.3.5) is not used to release the storage, the destructor shall not be implicitly called and any program that depends on the side effects produced by the destructor has undefined behavior.
所以是的，您可以通过重用其内存来结束对象的生命周期，即使是具有非平凡析构函数的对象，只要您不依赖于析构函数调用的副作用。
这适用于对象的非常量实例，例如 struct ImmutableBounds { const void* start; const void* end; }
你实际上问了 3 个不同的问题:)
1.不变性合约
只是 - 合同，而不是语言结构。
例如，在 Java 中，String class 的实例是不可变的。但这意味着 class 的所有方法都被设计为 return class 的新实例，而不是修改实例。
因此，如果您想将 Java 的 String 变成可变对象，则无法访问其源代码。
同样适用于用 C++ 或任何其他语言编写的 classes。您可以选择创建 wrapper（或使用代理模式），仅此而已。
2。使用放置构造函数并分配到已初始化的内存中。
这实际上是创建它们的初衷。 放置构造函数最常见的用例是 内存池 - 您预先分配一个大内存缓冲区，然后将您的东西分配到其中。
所以是的 - 这是合法的，没有人会介意。
3。使用放置分配器覆盖 class 实例的内容。
不要那样做。
有一种特殊的结构可以处理这种类型的操作，它被称为复制构造函数。
您写的内容在技术上是合法的，但几乎肯定没有用。
假设
struct Immutable {
const int x;
Immutable(int val):x(val) {}
};
对于我们真正简单的不可变类型。
auto var = Immutable(0);
::new (&var) Immutable(1);
这是完全合法的。
而且没用，因为您不能使用 var 来指代放置 new 之后存储在其中的 Immutable(1) 的状态。任何此类访问都是未定义的行为。
你可以这样做：
auto var = Immutable(0);
auto* pvar1 = ::new (&var) Immutable(1);
并且访问 *pvar1 是合法的。你甚至可以这样做：
auto var = Immutable(0);
auto& var1 = *(::new (&var) Immutable(1));
但在任何情况下您都不得在放置新内容后引用 var。
C++ 中的实际 const 数据是对编译器的承诺，您永远不会更改该值。这是与对 const 的引用或指向 const 的指针的比较，这只是建议您不要修改数据。
const 声明的结构成员是 "actually const"。编译器会假定它们从未被修改，也不会费心去证明它。
您在旧实例生效的地方创建新实例违反了此假设。
您可以这样做，但是您不能使用旧名称或指针 来引用它。 C++ 让你搬起石头砸自己的脚。往前走，我们敢。
这就是为什么这种技术是合法的，但几乎完全没有用。具有静态单一分配的优秀优化器已经知道您将在此时停止使用 var，并创建
auto var1 = Immutable(1);
它可以很好地重用存储空间。
在另一个变量之上校准新的位置通常是定义的行为。这通常是一个坏主意，而且 脆弱 。
这样做会结束旧对象的生命周期而不调用析构函数。如果某些特定假设成立（完全相同的类型，没有 const 问题），旧对象的引用和指针以及名称指的是新对象。
修改声明为 const 的数据，或包含 const 字段的 class，会导致引脚掉落时出现未定义的行为。这包括结束声明为 const 的自动存储字段的生命周期并在该位置创建一个新对象。旧名称、指针和引用不能安全使用。
[Basic.life3.8]/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:
(8.1) the storage for the new object exactly overlays the storage location which the original object occupied, and
(8.2) the new object is of the same type as the original object (ignoring the top-level cv-qualifiers), and
(8.3) 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
(8.4) the original object was a most derived object (1.8) of type T and the new object is a most derived object of type T (that is, they are not base class subobjects).
简而言之，如果您的不变性是通过 const 成员编码的，使用旧名称 或 指向旧内容的指针是 未定义的行为.
您可以使用 placement new 的 return 值来引用新对象，没有别的。
异常的可能性使得阻止执行未定义行为或必须立即退出的代码变得极其困难。
如果您需要引用语义，请使用指向 const 对象的智能指针或可选的 const 对象。两者都处理对象生命周期。第一个需要堆分配但允许移动（和可能的共享引用），第二个允许自动存储。两者都将手动对象生命周期管理从业务逻辑中移出。现在，两者都可以为空，但是无论如何手动都很难避免这种情况。
还考虑写时复制指针，这些指针允许逻辑 const 数据具有突变以提高效率。