Do std::optional and boost::optional respect alignment restrictions of the managed object?

Question

If a class T has an alignment requirement, such as one specified by the alignas keyword, are std::optional<T> and boost::optional<T> guaranteed to respect said alignment?

If they were simply wrapper classes for a T object and a bool initialized, then they would automatically align their T member as required, but the standard and boost documentation state that they can hold no object and deal well with expensive to construct objects. From this I understand that they don't simply contain a T. Rather, they seem to allocate a buffer upon which the T is constructed or destroyed manually. Therefore, the C++ language will not automatically align the buffer because it is not of type T.

So, do std::optional<T> and boost::optional<T> properly align their managed T object? Do they also provide optional<T>::operator new and optional<T>::operator new[] that respect the alignment requirement?

Isn’t the answer *obviously* yes? I can’t imagine a non-broken implementation that doesn’t respect the template type’s alignment. — Konrad Rudolph, Sep 04 '17 at 14:28
Because the expression `new std::optional` is not affected by the `alignas` specifier of `T` or of `std::optional`. — patatahooligan, Sep 04 '17 at 15:59

PaulR · Accepted Answer · 2018-03-26T12:08:41.650

6

A conforming implementation of std::optional must respect the alignment requirements of its value_type according to the C++17 standard draft:

23.6.3 Class template optional [optional.optional]

(...) The contained value shall be allocated in a region of the optional storage suitably aligned for the type T.

An implementor could use a union potentially containing the value as member, ensuring proper alignment.

As Thomas already mentioned while I was looking it up, boost::optional does ensure proper alignment by use of aligned_storage<T>

edited Mar 26 '18 at 12:08

answered Sep 04 '17 at 14:06

PaulR

3,587
14
24

1

Thanks for finding this. cppreference.com didn't mention anything on alignment and I assumed it was actually unspecified by the standard. It is in paragraph 23.6.3 which you might want to mention in your post for the sake of completeness. – patatahooligan Sep 04 '17 at 14:21
@patatahooligan: Thanks for the feedback, I added the heading to the answer. – PaulR Sep 04 '17 at 14:27

score 2 · Answer 2 · answered Sep 04 '17 at 14:01

In the GNU C++ implementation, std::optional derives from _Optional_Base<_Tp>, which in turn contains an _Optional_payload<_Tp>. This is a template with several specializations, all of which contains the following members:

  using _Stored_type = remove_const_t<_Tp>;
  struct _Empty_byte { };
  union {
      _Empty_byte _M_empty;
      _Stored_type _M_payload;
  };
  bool _M_engaged = false;

As you can see, the _M_payload is actually strongly typed, so any alignment attributes should carry over properly in this implementation.

The Boost implementation does not use a union. Instead, boost::optional<T> derives from optional_base<T>, which simply contains:

 typedef aligned_storage<T> storage_type ;
 bool m_initialized ;
 storage_type m_storage ;

The name of aligned_storage is a clue; the docs don't mention that the second template argument is optional and defaults to -1, which means boost::detail::max_align, which means to use the alignment a union type containing a bunch of primitive types up to 128 bits in length. So (from a cursory reading) Boost seems to be a bit more pessimistic than GNU, but will also get your alignment right.

I guess for the `boost` version, source code is adequate, but for the `std` version, I can't rely on specific implementations. I need a guarantee from the standard. — patatahooligan, Sep 04 '17 at 14:07

Do std::optional and boost::optional respect alignment restrictions of the managed object?

2 Answers2