将 char 数组转换为对象指针 - 这是 UB 吗？

Question

我最近看到一个这样的类，它用于“按需”构造对象，而由于各种原因而不必使用动态内存分配。

#include <cassert>

template<typename T>
class StaticObject
{
public:
    StaticObject() : constructed_(false)
    {
    }

    ~StaticObject()
    {
        if (constructed_)
            ((T*)object_)->~T();
    }

    void construct()
    {
        assert(!constructed_);

        new ((T*)object_) T;
        constructed_ = true;
    }

    T& operator*()
    {
        assert(constructed_);

        return *((T*)object_);
    }

    const T& operator*() const
    {
        assert(constructed_);

        return *((T*)object_);
    }

private:
    bool constructed_;
    alignas(alignof(T)) char object_[sizeof(T)];
};

这段代码，即将正确对齐的字符数组转换为对象指针，是否被 C++14 标准视为未定义行为，还是完全没问题？

Answer 1

该程序在技术上具有未定义的行为，尽管它可能适用于大多数实现。问题是从char* 到T* 的转换不能保证产生指向由placement new 创建的T 对象的有效指针，即使char* 指针表示用于的第一个字节的地址T 对象的存储空间。

[basic.compound]/3:

指向布局兼容类型的指针应具有相同的值表示和对齐要求 ([basic.align])。

一般来说，T 与char 或alignas(T) char[sizeof(T)] 的布局不兼容，因此不要求指针T* 与指针char* 或void* 具有相同的值表示形式.

[basic.compound]/4:

两个对象 a 和 b 是 pointer-interconvertible 如果：

• 它们是同一个对象，或者

• 一个是联合对象，另一个是该对象的非静态数据成员（[class.union]），或者

• 一个是标准布局类对象，另一个是该对象的第一个非静态数据成员，或者，如果该对象没有非静态数据成员，则该对象的任何基类子对象（[class.内存])，或

• 存在一个对象 c 使得 a 和 c 是指针可互转换的，并且 c 和 b 是指针可相互转换的。

如果两个对象是指针可互转换的，那么它们具有相同的地址，并且可以通过reinterpret_cast 从指向另一个对象的指针中获得指向其中一个对象的指针。 [ 注意： 一个数组对象和它的第一个元素不是指针可互转换的，即使它们有相同的地址。 — 尾注 ]

[旁白：DR 2287 在 C++17 发布后的第二个项目符号中将“标准布局联合”更改为“联合”。但这并不影响这个程序。]

由放置 new 创建的 T 对象不能与 object_ 或 object_[0] 指针互转换。并且注释暗示这可能是演员表的问题......

对于C风格的演员((T*)object_)，我们需要看到[expr.cast]/4：

执行的转换

• const_cast,

• static_cast,

• static_cast 后跟 const_cast，

• reinterpret_cast，或

• reinterpret_cast 后跟 const_cast

可以使用显式类型转换的强制转换符号来执行......

如果转换可以用以上列出的一种以上方式解释，则使用列表中第一个出现的解释，即使由该解释产生的强制转换是格式错误的。

除非T 是char 或cv-qualified char，否则这实际上是reinterpret_cast，所以接下来我们看看[expr.reinterpret.cast]/7：

对象指针可以显式转换为不同类型的对象指针。当对象指针类型的prvaluev转换为对象指针类型“pointer to cv T”时，结果为static_­cast<cv T*>(static_­cast< 简历 void*>(v)).

首先我们有一个从char* 到void* 的static_cast，它执行[conv.ptr]/2 中描述的标准转换：

“指向cvT”类型的纯右值，其中T 是一个对象类型，可以转换为“指向cv的指针”类型的纯右值>void"。此转换未更改指针值（[basic.compound]）。

这后面是从void* 到T* 的static_cast，在[expr.static.cast]/13 中进行了描述：

“指向cv1 void的指针”类型的纯右值可以转换为“指向cv2 T的指针”类型的纯右值，其中T是一个对象类型，并且 cv2 的 cv 限定与 cv1 相同或更高。如果原始指针值表示内存中某个字节的地址A，而A不满足T的对齐要求，则结果指针值未指定。否则，如果原始指针值指向一个对象 a，并且存在一个类型为 T（忽略 cv-qualification）的对象 b 可以与a，结果是一个指向b的指针。否则，指针值不会因转换而改变。

如前所述，T 类型的对象不能与object_[0] 指针互转换，因此该语句不适用，并且不能保证结果T* 指向T 对象！我们只剩下“指针值不变”这句话，但如果char* 和T* 指针的值表示形式相差太大，这可能不是我们想要的结果。

可以使用union 实现此类的符合标准的版本：

template<typename T>
class StaticObject
{
public:
    StaticObject() : constructed_(false), dummy_(0) {}
    ~StaticObject()
    {
        if (constructed_)
            object_.~T();
    }
    StaticObject(const StaticObject&) = delete; // or implement
    StaticObject& operator=(const StaticObject&) = delete; // or implement

    void construct()
    {
        assert(!constructed_);

        new(&object_) T;
        constructed_ = true;
    }

    T& operator*()
    {
        assert(constructed_);

        return object_;
    }

    const T& operator*() const
    {
        assert(constructed_);

        return object_;
    }

private:
    bool constructed_;
    union {
        unsigned char dummy_;
        T object_;
    }
};

甚至更好，因为这个类本质上是在尝试实现一个optional，如果你有std::optional，如果你没有，就使用boost::optional。

Answer 2

将 char 数组转换为对象指针 - 这是 UB 吗？

使用 C 风格的转换将一个指针（数组衰减为一个指针）转换为不在同一继承层次结构中的另一个指针执行重新解释转换。重新解释演员表本身永远不会有 UB。

但是，如果适当类型的对象尚未构造到该地址中，则间接转换的指针可能具有 UB。在这种情况下，已经在字符数组中构造了一个对象，因此间接具有明确定义的行为。编辑：如果不是严格的别名规则，间接将是 UB 免费的；有关详细信息，请参阅 ascheplers 的答案。 aschepler 展示了一个符合 C++14 的解决方案。在 C++17 中，可以通过以下更改更正您的代码：

void construct()
{
    assert(!constructed_);
    new (object_) T; // removed cast
    constructed_ = true;
}

T& operator*()
{
    assert(constructed_);
    return *(std::launder((T*)object_));
}

要将对象构造成另一种类型的数组，必须满足三个要求才能避免UB：必须允许另一种类型对对象类型进行别名（char、unsigned char和std::byte满足此要求所有对象类型），地址必须按照对象类型的要求与内存边界对齐，并且任何内存都不能与另一个对象的生命周期重叠（忽略数组的底层对象，这些对象允许为覆盖的对象起别名） .您的程序满足所有这些要求。

Answer 3

在给@aschepler 写评论后，我想我找到了正确的答案：

不，它不是 UB！

非常强烈的提示：aligned_storage 正是为了这样做。

• basic.compound[4] 为我们提供了“指针互转换”的定义。上述情况均不适用，因此 T* 和 unsigned char[...] 不是指针可互转换的。

• conv.ptr[2] 和expr.static.cast[13] 告诉我们reinterprer_cast<T*>(object_) 上发生了什么。基本上，（中间）转换为void* 不会改变指针的值，而从void* 转换为T* 也不会改变它：

  如果原始指针值表示内存中一个字节的地址A，而A不满足T的对齐要求，那么得到的指针值是未指定。否则，如果原始指针值指向对象a，并且存在与apointer-interconvertible的类型为T（忽略cv-qualification）的对象b，则结果是指向b的指针. 否则，指针值不会因转换而改变。

  我们在这里有一个正确对齐的，不是指针可互转换的类型。因此值不变。

• 现在在 P0137 之前（在another answer 找到）basic.compound[3] 说：

  如果一个类型为 T 的对象位于地址 A 处，则称其值为地址 A 的类型为 cv T* 的指针指向该对象，而不管该值是如何获得的。

  现在是basic.compound[3]

  指针类型的每个值都是以下之一：

  (3.1) 指向对象或函数的指针（据说该指针指向对象或函数），[...]

  我认为与此目的等效。

• 最后我们需要basic.lval[11]

  如果程序尝试通过类型与以下类型之一不相似 ([conv.qual]) 的泛左值访问对象的存储值，则行为未定义：52 [...]

  (11.3) char、unsigned char 或 std​::​byte 类型。

  这归结为别名规则，它只允许某些类型使用别名，我们的unsigned char 是其中的一部分。

总之：

• 我们符合对齐和别名规则
• 我们得到一个已定义的指向T* 的指针值（与unsigned char* 相同）
• 因此我们在那个地方有一个有效的对象

这基本上是@eeerorika 也有的。但我认为，从上面的论点来看，至少如果 T 没有任何 const 是引用成员，那么代码是完全有效的，在这种情况下必须使用 std::launder。即使这样，如果内存没有被重用（但仅用于创建 1 个T），那么它也应该是有效的。

然而，旧的 GCC (https://godbolt.org/z/Gjs05C 尽管docu 声明：

例如，unsigned int 可以给 int 取别名，但不能给 void* 或 double 取别名。 **一个字符类型可以别名任何其他类型。 **

这是bug

Answer 4

当您创建这样的StaticObject 时，它会为 T 对象保留具有正确对齐约束和正确大小的存储空间，但不会构造该对象。

当construct() 被调用时，它会调用placement-new 来构造保留存储中的对象（正确对齐且不为空）。这不是最自然的方式，但这里没有 UB。

唯一可能是 UB，是放置 new 是否会覆盖已经存在的对象。但这是通过assert() 阻止的。

Answer 5

你确实有未定义的行为。

object_ 不是T*，所以转换和取消引用它是 UB。您不能使用object_ 来引用新创建的对象。这也称为严格别名。

不过，修复很简单：只需创建一个新的成员变量T*，您可以使用它来访问构造的对象。然后你需要将放置 new 的结果分配给那个指针：

ptr = new(object_) T;

---

[basic.life]p1 说：

类型 T 的对象 o 的生命周期在以下情况下结束：

• 如果 T 是具有非平凡析构函数的类类型，则析构函数调用开始，或者

• 对象占用的存储被释放，或者被未嵌套在o中的对象重用。

因此，通过执行new (object_) T;，您将结束原始char[] 对象的生命周期，并开始我们将调用t 的新T 对象的生命周期。

现在我们要检查*((T*)object_)是否有效。

[basic.life]p8 突出显示重要部分：

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

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

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

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

第二点不成立（T vs char[]），所以不能使用object_作为指向新创建对象t的指针。