|  | Home | Libraries | People | FAQ | More | 
        The very minimum requirement of optional<T>
        is that T is a complete type
        and that it has a publicly accessible destructor. T
        doesn't even need to be constructible. You can use a very minimum interface:
      
optional<T> o; // uninitialized assert(o == none); // check if initialized assert(!o); // o.value(); // always throws
        But this is practically useless. In order for optional<T>
        to be able to do anything useful and offer all the spectrum of ways of accessing
        the contained value, T needs
        to have at least one accessible constructor. In that case you need to initialize
        the optional object with function emplace(), or if your compiler does not support it,
        resort to In-Place
        Factories:
      
optional<T> o; o.emplace("T", "ctor", "params");
        If T is MoveConstructible,
        optional<T> is
        also MoveConstructible and
        can be easily initialized from an rvalue of type T
        and be passed by value:
      
optional<T> o = make_T(); optional<T> p = optional<T>();
        If T is CopyConstructible, optional<T> is
        also CopyConstructible
        and can be easily initialized from an lvalue of type T:
      
T v = make_T(); optional<T> o = v; optional<T> p = o;
        If T is not MoveAssignable, it is still possible to
        reset the value of optional<T>
        using function emplace():
      
optional<const T> o = make_T(); o.emplace(make_another_T());
        If T is Moveable
        (both MoveConstructible and
        MoveAssignable) then optional<T> is
        also Moveable and additionally
        can be constructed and assigned from an rvalue of type T.
      
        Similarly, if T is Copyable (both CopyConstructible and CopyAssignable) then optional<T>
        is also Copyable and additionally
        can be constructed and assigned from an lvalue of type T.
      
        T is not
        required to be DefaultConstructible.