|  | 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