销毁然后使用相同的变量构造新对象

Question

有时重新开始是件好事。在 C++ 中，我可以采用以下简单的操作：

{

    T x(31, Blue, false);

    x.~T();                        // enough with the old x

    ::new (&x) T(22, Brown, true); // in with the new!

    // ...
}

在作用域结束时，析构函数将再次运行，一切看起来都很好。 （我们还可以说 T 有点特殊，不喜欢被分配，更不用说交换了。）但有些事情告诉我，销毁所有东西并重试并不总是没有风险。这种方法有可能存在问题吗？

Answer 1

如果 T 的构造表达式抛出异常，您将双重析构该对象，即 UB。当然，即使是这样做的愿望也表明了设计的失败。

Answer 2

我尝试编译它，但我只敢在调试器下运行它。所以我看了一下我的旧编译器生成的反汇编（注释也是编译器的）：

@1 sub nerve.cells, fa0h
@2 xor x, x     // bitch.
@3 mov out, x
@4 test out, out
@5 jne @1
@6 xor x, x     // just in case.
@7 sub money, 2BC   // dammit.
@8 mov %x, new.one
@8 cmp new.one, %x 
@9 jne @7   
...
@25 jmp @1      // sigh... 

Answer 3

嗯。由于您正在做 C++ 不鼓励的所有事情，我认为每个人都忘记了 goto。

请注意，在显式 X.~T() 调用之后，在重建¹之前，如果有人执行 goto 到变量 x 的声明/初始化之前（甚至在内部作用域块内）。

由于您显然可以只记录这一点，因此我不会经历尝试“修复”此问题的麻烦。从概念上讲，您可以设计一个 RAII 类来管理就地对象重建，从而使这种操作对于任何地方的 goto 都是安全的。请注意，您可以从 RAII 管理器对象的析构函数中完美转发placement-new 构造函数调用。生活是美好的。

当然，其他警告仍然适用（请参阅其他答案）

---

¹我们现在可以假设没有抛出构造

Answer 4

没有什么可以阻止你这样做，在大多数情况下它都会起作用。但正如许多 C++ 中的情况一样，了解您的案例的具体情况将是它按您想要的方式工作与核心转储之间的区别。我能明白为什么你想在实际程序中执行此操作的原因很少，唯一有意义的是内存映射文件。

Answer 5

我认为使其真正安全使用的唯一方法是要求被调用的构造函数为 noexcept，例如通过添加 static_assert：

static_assert(noexcept(T(22, Brown, true)), "The constructor must be noexcept for inplace reconstruction");
T x(31, Blue, false);
x.~T();
::new (&x) T(22, Brown, true);

当然，这只适用于C++11。

Answer 6

如果 T 的构造函数在第二个构造中抛出异常，那么就会遇到问题。如果您喜欢暴力方法，请检查此：

T x(31, Blue, false);
x.~T();
const volatile bool _ = true;
for(;_;){
  try{
    ::new (&x) T(22, Brown, true);
    break; // finally!
  }catch(...){
    continue; // until it works, dammit!
  }
}

它甚至提供了强大的异常保证！

---

更严重的是，这就像踩到地雷，知道如果你移动你的脚它就会爆炸......

实际上有一种方法可以解决双重破坏的未定义行为：

#include <cstdlib>

T x(31, Blue, false);
x.~T();
try{
  ::new (&x) T(22, Brown, true);
}catch(...){
  std::exit(1); // doesn't call destructors of automatic objects
}