![]() |
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
.