c++ - memcpy 可以用于 std::aligned_storage 吗？

Question

std::aligned_storage::type 是 POD 类型。 POD类型可以memcpy。但是，如果将新的非平凡可复制类型放置到 std::aligned_storage 会发生什么？它可以 memcpy 那个 std::aligned_storage 吗？

非普通可复制类型(非 POD 类型)不能 memcpy，行为未定义。如果 std::aligned_storage memcpy 是不可平凡复制的类型，它是否也是未定义的行为？

#include <new>
#include <type_traits>
#include <cstring>
#include <iostream>

struct y { int a; } ;

// non-trivially-copyable
struct t
{
    y a;
    int* p;
    t(){ p = new int{ 300 }; }
    t( t const& ){ a.a += 100; }
    ~t(){ delete p; }
};

int main()
{   // Block 1
    { 
        t a; a.a.a = 100;
        t b; b.a.a = 200;
        // std::memcpy(&b,&a,sizeof(t));  // abort...non-trivially-copyable
    }
    // Block 2
    {
        std::aligned_storage_t<sizeof(t),alignof(t)> s;
        {
            t a;
            a.a.a = 100;
            std::memcpy(&s,&a,sizeof(t)); // OK...Coincidence? Behavior is undefined?
        }
        std::cout << static_cast<t*>(static_cast<void*>(&s))->a.a << std::endl; // OK...
    }
    // Block 3
    {
        std::aligned_storage_t<sizeof(t),alignof(t)> s1; new( &s1 ) t; 
        std::aligned_storage_t<sizeof(t),alignof(t)> s2; new( &s2 ) t;

        std::memcpy(&s2,&s1,sizeof(t)); // trivially-copyable????
    }
}

我认为它也是未定义的。但是，我们有工作。这是巧合吗？

Answer 1

首先:正如在 this thread 上讨论的那样，C++ 标准只定义了 memcpy 的行为，用于简单可复制的对象。该线程给出了一个具体示例，说明它如何中断非平凡可复制的选项

因此，对标准的狭义解释会说调用 memcpy 的行为会导致 UB。

然而，更常识性的解释是复制字节是可以的，但任何将目标视为实际包含相同类型对象的尝试都会导致 UB。特别是在程序依赖于析构函数的副作用的情况下，就像你的一样。我的其余回答基于后一种解释。

---

从第 2 block 开始:

std::aligned_storage_t<sizeof(t),alignof(t)> s;
{
    t a;
    a.a.a = 100;
    std::memcpy(&s,&a,sizeof(t)); 
}
std::cout << static_cast<t*>(static_cast<void*>(&s))->a.a << std::endl

由于 t 不可复制，我们还没有在 s 的存储中创建有效的 t 对象。所以尝试使用 s 就好像它包含一个有效的 t 对象肯定会导致未定义的行为。当 UB 发生时，任何结果都会随之而来，包括(但不限于)它似乎“按预期工作”。

---

在 block 1 中(如果 memcpy 未注释):

{
    t a; a.a.a = 100;
    t b; b.a.a = 200;
    std::memcpy(&b,&a,sizeof(t));  // abort...non-trivially-copyable
}

这里我们有析构函数的副作用。 memcpy 结束了 a 的生命周期(因为 a 的存储被重新使用)。然而，代码将继续尝试调用 a 上的析构函数。

在这种情况下，即使拷贝“似乎可以工作”，您的中止也可能来自 a.p 的双重释放。

如果我们将 t 更改为不可平凡复制的类型，但没有析构函数的副作用，那么这个示例将不清楚。

block 2 中没有这样的双重释放，因为没有为存储在 s 中的 t 调用析构函数。

---

第 3 block :

这类似于 block 2:memcpy 不创建对象。它“似乎有效”，因为您从不为 aligned_storage 中的对象调用析构函数。

事实上，根据我们对memcpy的常识性解释，这里没有UB，因为您从未尝试使用复制字节的结果并且目标没有调用析构函数. (如果您将 cout 行复制到此处，它会导致 UB，原因与 block 2 中的相同)。

---

相关讨论: 即使是普通的可复制类也是 still murky

对于 malloc 空间或 aligned_storage 中的对象，C++ 标准并不清楚对象生命周期何时开始的问题。有一个提交N3751认识到这需要清理，但仍有很多工作要做。

在您的 Block 2 中，s 的生命周期尚未开始。这是因为 t 具有非平凡的初始化。 (实际上 C++ 标准也没有明确说明这一点)。但是 Block 1 的 a 是一个生命周期已经开始的对象。

N3751 提出(如果 t 是可简单复制的)那么 memcpy 实际上将开始 s 的生命周期。