std::optional implemented as union vs char[]/aligned_storage

  • A+
Category:Languages

While reading through GCC's implementation of std::optional I noticed something interesting. I know boost::optional is implemented as follows:

template <typename T> class optional {     // ... private:     bool has_value_;     aligned_storage<T, /* ... */> storage_; } 

But then both libstdc++ and libc++ (and Abseil) implement their optional types like this:

template <typename T> class optional {     // ... private:     struct empty_byte {};     union {         empty_byte empty_;         T value_;     };     bool has_value_; } 

They look to me as they are functionally identical, but are there any advantages of using one over the other? (Except for the obvious lack of placement new in the latter which is really nice.)

 


They look to me as they are functionally identical, but are there any advantages of using one over the other? (Except for the obvious lack placement new in the latter which is really nice.)

It's not just "really nice" - it's critical for a really important bit of functionality, namely:

constexpr std::optional<int> o(42); 

There are several things you cannot do in a constant expression, and those include new and reinterpret_cast. If you implemented optional with aligned_storage, you would need to use the new to create the object and reinterpret_cast to get it back out, which would prevent optional from being constexpr friendly.

With the union implementation, you don't have this problem, so you can use optional in constexpr programming (even before the fix for trivial copyability that Nicol is talking about, optional was already required to be usable as constexpr).

Comment

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: