C++11 §3.8.1 声明，对于具有普通析构函数的对象，我可以通过分配给它的存储来结束它的生命周期。我想知道微不足道的析构函数是否可以延长对象的生命周期并通过“销毁一个对象”导致别名问题，而我早就结束了它的生命周期。

首先，我知道一些安全且无别名的东西

void* mem = malloc(sizeof(int));
int*  asInt = (int*)mem;
*asInt = 1; // the object '1' is now alive, trivial constructor + assignment
short*  asShort = (short*)mem;
*asShort = 2; // the object '1' ends its life, because I reassigned to its storage
              // the object '2' is now alive, trivial constructor + assignment
free(mem);    // the object '2' ends its life because its storage was released

现在，对于一些不太清楚的事情:

{
    int asInt = 3; // the object '3' is now alive, trivial constructor + assignment
    short* asShort = (short*)&asInt; // just creating a pointer
    *asShort = 4; // the object '3' ends its life, because I reassigned to its storage
                  // the object '4' is now alive, trivial constructor + assignment
    // implicitly, asInt->~int() gets called here, as a trivial destructor
}   // 'the object '4' ends its life, because its storage was released

§6.7.2 声明自动存储持续时间的对象在作用域末尾被销毁，表明析构函数被调用。 如果有一个要销毁的 int，*asShort = 2 是一个别名冲突，因为我取消引用了一个不相关类型的指针。但是，如果整数的生命周期在 *asShort = 2 之前结束，那么我将在 short 上调用 int 析构函数。

我看到几个关于此的竞争部分:

§3.8.8 阅读

If a program ends the lifetime of an object of type T with static (3.7.1), thread (3.7.2), or automatic (3.7.3) storage duration and if T has a non-trivial destructor,39 the program must ensure that an object of the original type occupies that same storage location when the implicit destructor call takes place; otherwise the behavior of the program is undefined.

在我看来，他们调用具有非平凡析构函数的类型 T 作为产生未定义行为的事实似乎表明在具有平凡析构函数的存储位置中具有不同的类型 已定义，但我在规范中找不到定义它的任何地方。

如果将平凡的析构函数定义为 noop，这样的定义会很容易，但规范中关于它们的内容非常少。

§6.7.3 表示 goto 允许跳入和跳出其变量具有平凡构造函数和平凡析构函数的范围。这似乎暗示了一种允许跳过微不足道的析构函数的模式，但规范中关于在作用域末尾销毁对象的较早部分没有提到这一点。

最后，是时髦的阅读:

§3.8.1 表示我可以随时开始一个对象的生命周期，只要它的构造函数是微不足道的。这似乎表明我可以做类似的事情

{
    int asInt = 3;
    short* asShort = (short*)&asInt;
    *asShort = 4; // the object '4' is now alive, trivial constructor + assignment
    // I declare that an object in the storage of &asInt of type int is
    // created with an undefined value.  Doing so reuses the space of
    // the object '4', ending its life.

    // implicitly, asInt->~int() gets called here, as a trivial destructor
}

这些阅读 Material 中唯一似乎暗示任何别名问题的是 §6.7.2 本身。看起来，当作为整个规范的一部分阅读时，微不足道的析构函数不应该以任何方式影响程序(尽管出于各种原因)。有谁知道在这种情况下会发生什么？

最佳答案

在您的第二个代码片段中:

{
    int asInt = 3; // the object '3' is now alive, trivial constructor + assignment
    short* asShort = (short*)&asInt; // just creating a pointer
    *asShort = 4; 
    // Violation of strict aliasing. Undefined behavior. End of.
}

这同样适用于您的第一个代码片段。它不是“安全的”，但它通常会起作用，因为 (a) 没有特别的理由让编译器被实现以致于它不起作用，并且 (b) 在实践中，编译器必须至少支持一些违反严格别名，否则无法使用编译器实现内存分配器。

据我所知，如果您之后阅读 asInt，DFA 可以“检测”到 asInt未被修改(因为它仅被严格别名违规修改，即 UB)，并在写入 *asShort 后移动 asInt 的初始化。这是我们对标准的任何一种解释的 UB——在我的解释中是因为严格的别名违规，在你的解释中是因为 asInt 在其生命周期结束后被读取。所以我们都很高兴这不起作用。

但是我不同意你的解释。如果您认为分配给 asInt 的存储的 部分 会结束 asInt 的生命周期，那么这与生命周期声明直接矛盾自动对象的范围是它的范围。好的，所以我们可以接受这是一般规则的异常(exception)情况。但这意味着以下内容无效:

{
    int asInt = 0;
    unsigned char *asChar = (unsigned char*)&asInt;
    *asChar = 0; // I've assigned the storage, so I've ended the lifetime, right?
    std::cout << asInt; // using an object after end of lifetime, undefined behavior!
}

除了允许 unsigned char 作为别名类型(以及定义 all-bits-0 表示整数类型的“0”)的全部意义在于使这样的代码工作。所以我非常不愿意对标准的任何部分进行解释，这意味着这行不通。

Ben 在下面的评论中给出了另一种解释，即 *asShort 赋值不会结束 asInt 的生命周期。

关于c++ - 琐碎的析构函数会导致别名吗，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18667318/