Question

我偶然发现了基于LLVM Optional.h类的Optional<T>的实现，并且无法弄清楚为什么以它的方式实现它。

为了简短起见，我只是粘贴了一些我不明白的部分：

template <typename T>
class Optional
{
private:
    inline void* getstg() const { return const_cast<void*>(reinterpret_cast<const void*>(&_stg)); }
    typedef typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type storage_type;
    storage_type _stg;
    bool _hasValue;

public:

    Optional(const T &y) : _hasValue(true)
    {
        new (getstg()) T(y);
    }

    T* Get() { return reinterpret_cast<T*>(getstg()); }
}

我能想到的最天真的实现：

template <typename T>
class NaiveOptional
{
private:
    T* _value;
    bool _hasValue;

public:
    NaiveOptional(const T &y) : _hasValue(true), _value(new T(y))
    {
    }   

    T* Get() { return _value; }
}

问题：

如何解释storage_type？作者的意图是什么？
这一行的语义是什么：new (getstg()) T(y);？
为什么没有天真的实施工作（或Optional<T>班的专业人员对NaiveOptional<T>的优势？）

Answer 1

简短的回答是＆＃34;表现＆＃34;。

更长的答案：

storage_type提供了一个内存区域，其中（a）大到足以适合类型T，（b）正确对齐类型T.未对齐的内存访问速度较慢。另请参阅doc。
new (getstg()) T(y)是新的展示位置。它不分配内存，而是在传递给它的内存区域中构造一个对象。 doc（在new的所有形式上 - 搜索＆＃34;展示位置新＆＃34;）。
天真的实现确实有效，但性能更差。它使用动态内存分配，这通常可能成为瓶颈。 Optional<T>实现不使用动态内存分配（参见上面的内容）。

Answer 2

应该从函数返回Std :: optional。这意味着您必须将指针引用的内容存储在某处。这违背了本课的目的

此外，你不能使用普通的T，因为否则你将不得不以某种方式构建它。可选允许内容未初始化，某些类型不能默认构建。

为了使类在支持的类型方面更加灵活，使用拟合和正确对齐的存储。并且只有当optional是活动的时，才会在其上构造真实类型

你的想法可能就像std :: variant？

为什么LLVM的可选<t>以这种方式实现？

2 个答案: