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

为了简短起见,我只是粘贴了我不理解的部分：

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); ？
>为什么天真的实现不起作用(或者,可选< T>类的优点是否超过NaiveOptional< T>)？

解决方法:

简短的回答是“表现”.

更长的回答：

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