在初始化内存上使用新位置是否合法？

Question

我正在探索在 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++ 中是合法的还是我应该期待未定义的行为？如果它依赖于标准，我可以期望它工作的最小/最大标准版本是什么？

附录：因为似乎人们在 2019 年仍在阅读这篇文章，所以请注意一下——这种模式实际上在现代（17 后）C++ 中使用std::launder() 是合法可行的。

Answer 1

你写的东西在技术上是合法的，但几乎可以肯定是没用的。

假设

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));

但在任何情况下，在您将 new'd 放置在 var 上之后，您都不能提及它。

C++ 中的实际const 数据向编译器承诺，您永远不会更改值。这是与对 const 的引用或指向 const 的指针的比较，后者只是建议您不要修改数据。

声明为const 的结构的成员“实际上是常量”。编译器会假定它们从未被修改过，也不会费心去证明它。

您在旧实例所在的位置创建一个新实例违反了这一假设。

您可以这样做，但您不能使用旧名称或指针来引用它。 C++ 让你在脚下开枪。去吧，我们敢。

这就是为什么这种技术是合法的，但几乎完全没用。具有静态单一分配的优秀优化器已经知道您将在此时停止使用var，并创建

auto var1 = Immutable(1);

它可以很好地重复使用存储。

---

在另一个变量之上调整新位置通常是定义的行为。这通常是个坏主意，而且它脆弱。

这样做会结束旧对象的生命周期而不调用析构函数。如果某些特定假设成立（完全相同的类型，没有 const 问题），则对旧对象的引用和指针以及旧对象的名称都会引用新对象。

修改声明为 const 的数据或包含 const 字段的类会导致引脚掉落时出现未定义的行为。这包括结束声明为 const 的自动存储字段的生命周期并在该位置创建一个新对象。旧名称、指针和引用不安全使用。

[Basic.life 3.8]/8:

如果在一个对象的生命周期结束之后并且在该对象占用的存储空间被重用之前，或者 释放时，在原对象占用的存储位置创建一个新对象，一个指针 指向原始对象、引用原始对象的引用或原始对象的名称 对象将自动引用新对象，一旦新对象的生命周期开始，就可以 用于操作新对象，如果：

• (8.1) 新对象的存储恰好覆盖了原始对象占用的存储位置， 和

• (8.2) 新对象与原始对象的类型相同（忽略顶级 cv 限定符），并且

• (8.3) 原始对象的类型不是 const 限定的，并且，如果是类类型，则不包含任何非静态 类型为 const 限定或引用类型的数据成员，以及

• (8.4) 原始对象是类型最衍生的对象（1.8） 吨 并且新对象是最衍生的 类型的对象 吨 （也就是说，它们不是基类子对象）。

简而言之，如果您的不变性是通过const 成员编码的，那么使用旧名称​​或指向旧​​内容的指针是未定义行为。

您可以使用placement new 的返回值来引用新对象，仅此而已。

---

异常可能性使得阻止执行未定义行为或必须立即退出的代码变得极其困难。

如果您想要引用语义，请使用指向 const 对象或可选 const 对象的智能指针。两者都处理对象生命周期。第一个需要堆分配但允许移动（可能还有共享引用），第二个允许自动存储。两者都将手动对象生命周期管理移出业务逻辑。现在，两者都可以为空，但无论如何手动操作都很难避免这种情况。

为了提高效率，还考虑允许在逻辑上带有突变的 const 数据的写指针复制。

Answer 2

来自 C++ 标准草案 N4296：

3.8 对象生命周期
[...]
T 类型对象的生命周期在以下情况下结束：
(1.3) — 如果 T 是一个类 使用非平凡的析构函数（12.4）键入，析构函数调用开始， 或
(1.4) — 对象占用的存储空间被重用或 已发布。
[...]
4 程序可以通过以下方式结束任何对象的生命周期 重用对象占用的存储空间或通过显式调用 具有非平凡类类型的对象的析构函数 析构函数。对于具有非平凡的类类型的对象 析构函数，程序不需要调用析构函数 在对象占用的存储空间被重用或 释放；但是，如果没有显式调用析构函数或 如果不使用删除表达式 (5.3.5) 来释放存储，则 不应隐式调用析构函数，并且任何依赖于 关于析构函数产生的副作用有未定义的行为。

所以是的，只要不依赖析构函数调用的副作用，您可以通过重用对象的内存来结束对象的生命周期，即使是具有非平凡析构函数的对象也是如此。

_{这适用于你有像struct ImmutableBounds { const void* start; const void* end; }这样的对象的非常量实例时}

Answer 3

你实际上问了 3 个不同的问题 :)

1.不变合约

就是这样 - 合同，而不是语言结构。

例如，在 Java 中，String 类的实例是不可变的。但这意味着类的所有方法都被设计为返回类的新实例，而不是修改实例。

所以如果你想把 Java 的 String 变成一个可变对象，你不能，因为你不能访问它的源代码。

同样适用于用 C++ 或任何其他语言编写的类。您可以选择创建 wrapper（或使用代理模式），仅此而已。

2。使用放置构造函数并分配到一个已初始化的内存中。

这实际上就是他们最初创建的目的。 放置构造函数最常见的用例是 内存池 - 您预先分配一个大内存缓冲区，然后将您的东西分配到其中。

所以是的 - 这是合法的，没有人会介意。

3.使用放置分配器覆盖类实例的内容。

不要那样做。

有一个特殊的构造可以处理这种类型的操作，它被称为复制构造函数。