如何创建一个数组并开始它的生命周期而不开始它的任何元素的生命周期？

Question

任何类型的数组都是implicit-lifetime objects，也可以是begin the lifetime of implicit-lifetime object, without beginning the lifetime of its subobjects。

据我所知，在不以不会导致 UB 的方式开始其元素的生命周期的情况下创建数组的可能性是隐式生命周期对象的动机之一，请参阅http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2020/p0593r6.html。

现在，正确的做法是什么？分配内存并返回指向数组的指针就足够了吗？或者还有什么需要注意的？

也就是说，这段代码是否有效，它是否创建了一个包含未初始化成员的数组，或者我们仍然有 UB？

// implicitly creates an array of size n and returns a pointer to it
auto arrPtr = reinterpret_cast<T(*)[]>(::operator new(sizeof(T) * n, std::alignval_t{alignof(T)}) );
// is there a difference between reinterpret_cast<T(*)[]> and reinterpret_cast<T(*)[n]>?
auto arr = *arrPtr; // de-reference of the result in previous line.

这个问题可以重述如下。

根据https://en.cppreference.com/w/cpp/memory/allocator/allocate，allocate 函数函数在存储中创建T[n] 类型的数组并开始其生命周期，但不会开始其任何元素的生命周期。强>

一个简单的问题 - 它是如何完成的？ （忽略constexpr 部分，但我不介意答案中是否也解释了constexpr 部分）。

PS：提供的代码对 c++20 有效（假设它是正确的），但据我所知，不适用于早期标准。

我相信这个问题的答案也应该回答我之前提出的两个类似问题。

1. Arrays and implicit-lifetime object creation。
2. Is it possible to allocatate uninialized array in a way that does not result in UB。

编辑：我添加了一些代码 sn-ps，以使我的问题更清楚。我将不胜感激，解释哪些是有效的，哪些是无效的。

PS：请随意将malloc 替换为对齐版本，或::operator new 变体。据我所知，这并不重要。

示例 #1

T* allocate_array(std::size_t n)
{
    return reinterpret_cast<T*>( malloc(sizeof(T) * n) ); 
    // does it return an implicitly constructed array (as long as 
    // subsequent usage is valid) or a T* pointer that does not "point"
    // to a T object that was constructed, hence UB
    // Edit: if we take n = 1 in this example, and T is not implicit-lifetime 
    // type, then we have a pointer to an object that has not yet been
    // constructed and and doesn't have implicit lifetime - which is bad
}

示例 #2。

T* allocate_array(std::size_t n)
{
    // malloc implicitly constructs - reinterpet_cast should a pointer to 
    // suitably created object (a T array), hence, no UB here. 
    T(*)[] array_pointer = reinterpret_cast<T(*)[]>(malloc(sizeof(T) * n) );
    // The pointer in the previous line is a pointer to valid array, de-reference
    // is supposed to give me that array
    T* array = *array_pointer;
    return array;
}

示例 #3 - 与 2 相同，但数组的大小是已知的。

T* allocate_array(std::size_t n)
{
    // malloc implicitly constructs - reinterpet_cast should a pointer to 
    // suitably created object (a T array), hence, no UB here. 
    T(*)[n] n_array_pointer = reinterpret_cast<T(*)[n]>(malloc(sizeof(T) * n) );
    // The pointer in the previous line is a pointer to valid array, de-reference
    // is supposed to give me that array
    T* n_array = *n_array_pointer;
    return n_array;
}

这些都有效吗？

---

答案

虽然标准的措辞不是 100% 清楚，但在更仔细地阅读论文之后，动机是使转换为 T* 合法，而不是转换为 T(*)[]。 Dynamic construction of arrays。此外，the changes to the standard by the authors of the paper 暗示演员应该是T* 而不是T(*)[]。因此，接受the answer by Nicol Bolas 作为我问题的正确答案。

Answer 1

隐式对象创建的全部意义在于它是隐式。也就是说，你不做任何事情来让它发生。一旦 IOC 发生在一块内存上，您就可以使用该内存，就好像有问题的对象存在一样，只要您这样做，您的代码就可以工作。

当你从allocator_traits<>::allocate 得到你的T* 时，如果你给指针加 1，那么函数返回了一个至少有 1 个元素的数组（新指针可能是过去的指针数组）。如果再次加 1，则该函数返回了一个至少包含 2 个元素的数组。等等。这些都不是未定义的行为。

如果你做了一些与此不一致的事情（转换为不同的指针类型并表现得好像那里有一个数组），或者你表现得好像数组超出了 IOC 应用的存储大小，那么你获得 UB。

所以allocator_traits::allocate 真的不需要做任何事情，只要分配器分配的内存隐式创建对象。

---

// does it return an implicitly constructed array (as long as 
// subsequent usage is valid) or a T* pointer that does not "point"
// to a T object that notconstructed, hence UB

两者都不是。它返回一个指针（类型为T），指向可能已经隐式创建的对象的存储。 隐式创建了哪些对象取决于您如何使用此存储。并且仅仅做一个演员并不构成“使用”存储。

导致 UB 的不是 reinterpret_cast； using the pointer 由不正确的reinterpret_cast 返回，这就是问题所在。而且由于 IOC 基于会导致 UB 的操作进行工作，因此 IOC 并不关心您将指针投射到什么。

国际奥委会规则的重要组成部分是推论“suitable created object”规则。这条规则说某些操作（如malloc 和operator new）返回一个指向“合适的创建对象”的指针。从本质上讲，它回到了量子叠加：如果 IOC 追溯创建一个对象以使您的代码工作，那么这些函数会追溯返回一个指针，该指针指向所创建的使您的代码工作的任何对象。

因此，如果您的代码将指针用作T* 并对该指针进行指针运算，则malloc 返回指向Ts 数组的第一个元素的指针。这个数组有多大？这取决于：分配有多大，你的指针算术做了多远？里面有直播Ts 吗？这取决于：您是否尝试访问数组中的任何 Ts？