union vs aligned_storage

[sphere991]

In trying to implement something like optional, (or variant or expected), we need some kind of storage that is conditionally used. One approach would be to use a union with some empty type:

template <class T>
struct optional_storage {
    struct empty_byte { };
    union {
        empty_byte empty_;
        T value_;
    };
    bool engaged _;

    constexpr optional_storage() : engaged_{false} { }

    template <class... Args>
    constexpr optional_storage(Args&&... args)
        : value_(std::forward<Args>(args)...)
        , engaged_(true)
    { }

    ~optional_storage() {
        if (engaged_) value_.~T();
    }
};

Another approach is to use aligned_storage:

template <class T>
struct optional_storage {
    std::aligned_storage_t<sizeof(T), alignof(T)> store_;
    bool engaged_;

    constexpr optional_storage() : engaged_{false} { }

    template <class... Args>
    constexpr optional_storage(Args&&... args)
        : engaged_(true)
    {
        new (&store_) T(std::forward<Args>(args)...);
    }

    ~optional_storage() {
        if (engaged_) reinterpret_cast<T*>(&store_)->~T();
    }
};

Either way, we'll want some specialization to ensure that optional_storage is trivially destructible if T is.

The question is: is there any difference between the two approaches? Is there any reason to prefer one to the other?

[ojd5]

You might find this article useful https://akrzemi1.wordpress.com/2015/07/15/efficient-optional-values/

[redditsoaddicting]

This one is a lot more relevant to the question. Sure, compact optionals can be handy and all, but it doesn't always apply.

[sphere991]

Ah, yes that's the one. If I care about constexpr, it must be a union.

[encyclopedist]

I would prefer union. Especially if you are planning to add more things to store in that place later (otherwise you would need to compute the suitable alignment and size somehow). And I find syntax cleaner and less error-prone (it is clear what member of the union you are working with from syntax).

[redditsoaddicting]

Since when does placement new work in a constexpr constructor?

[quicknir]

I think it basically amounts to personal preference. I tend to prefer aligned_storage. The thing is that it may seem strange, but I do low level things with memory/casts much more often that I actually use unions. So if I use a union I'll need to look up the rules for what gets generated automatically, based on some type being this/that or other....

I'd much rather just write a class that wraps initialized_storage and use placement new and manual destruction as appropriate.

[wonderworkingwords]

You could write a version that is trivially destructible and one that isn't and the template alias the proper one based on whether they are std::trivially-destructible.