|  | Home | Libraries | People | FAQ | More | 
      This library assumes that T's
      destructor does not throw exceptions. If it does, the behaviour of many operations
      on optional<T> is
      undefined.
    
The following mutating operations never throw exceptions:
optional<T>::operator= ( none_t ) noexcept
        optional<T>::reset() noexcept
        In addition, the following constructors and the destructor never throw exceptions:
optional<T>::optional()
          noexcept
        optional<T>::optional( none_t ) noexcept
        Regarding the following assignment functions:
optional<T>::operator= ( optional<T> const& )
        optional<T>::operator= ( T const& )
        template<class U> optional<T>::operator= ( optional<U> const& )
        template<class InPlaceFactory> optional<T>::operator= ( InPlaceFactory
          const&
          )
        template<class TypedInPlaceFactory> optional<T>::operator= ( TypedInPlaceFactory
          const&
          ) 
        optional<T>::reset( T const& )
        
      They forward calls to the corresponding T's
      constructors or assignments (depending on whether the optional object is initialized
      or not); so if both T's constructor
      and the assignment provide strong exception safety guarantee, optional<T>'s assignment
      also provides strong exception safety guarantee; otherwise we only get the
      basic guarantee. Additionally, if both involved T's
      constructor and the assignment never throw, optional<T>'s
      assignment also never throws.
    
      Unless T's constructor or assignment
      throws, assignments to optional<T>
      do not throw anything else on its own. A throw during assignment never changes
      the initialization state of any optional object involved:
    
optional<T> opt1(val1); optional<T> opt2(val2); assert(opt1); assert(opt2); try { opt1 = opt2; // throws } catch(...) { assert(opt1); assert(opt2); }
This also applies to move assignments/constructors. However, move operations are made no-throw more often.
      Operation emplace provides
      basic exception safety guarantee. If it throws, the optional object becomes
      uninitialized regardless of its initial state, and its previous contained value
      (if any) is destroyed. It doesn't call any assignment or move/copy constructor
      on T.
    
      Unless swap on optional is
      customized, its primary implementation forwards calls to T's
      swap or move constructor (depending
      on the initialization state of the optional objects). Thus, if both T's swap
      and move constructor never throw, swap
      on optional<T> never
      throws. similarly, if both T's
      swap and move constructor offer
      strong guarantee, swap on
      optional<T> also
      offers a strong guarantee.
    
      In case swap on optional is
      customized, the call to T's
      move constructor are replaced with the calls to T's
      default constructor followed by swap.
      (This is more useful on older compilers that do not support move semantics,
      when one wants to acheive stronger exception safety guarantees.) In this case
      the exception safety guarantees for swap
      are reliant on the guarantees of T's
      swap and default constructor