![]() |
Home | Libraries | People | FAQ | More |
![]() |
Note |
|---|---|
The following section contains various |
optional<T>::optional() noexcept;
optional.
*this is uninitialized.
optional<T> def ; assert ( !def ) ;
optional<T>::optional( none_t ) noexcept;
optional uninitialized.
*this is uninitialized.
T's
default constructor is not called.
The expression boost::none
denotes an instance of boost::none_t
that can be used as the parameter.
#include <boost/none.hpp> optional<T> n(none) ; assert ( !n ) ;
optional<T>::optional( T const& v )
is_copy_constructible<T>::value
is true.
optional.
*this is initialized
and its value is a copy of v.
T::T( T const&
) throws.
T::T( T const&
) is called.
T::T( T const&
); in that case, this constructor
has no effect.
T v; optional<T> opt(v); assert ( *opt == v ) ;
optional<T>::optional( T&& v )
is_move_constructible<T>::value
is true.
optional.
*this is initialized
and its value is move-constructed from v.
T::T( T&& )
throws.
T::T( T&& )
is called.
T::T( T&& );
in that case, the state of v
is determined by exception safety guarantees for T::T(T&&).
T v1, v2; optional<T> opt(std::move(v1)); assert ( *opt == v2 ) ;
optional<T>::optional( bool condition, T const& v ) ;
optional<T>::optional( T const& v )
optional<T>::optional()
optional<T>::optional( optional const& rhs );
is_copy_constructible<T>::value
is true.
optional.
*this
is initialized and its value is a copy of the
value of rhs; else
*this
is uninitialized.
T::T( T const&
) throws.
T::T(T const& )
is called.
T::T( T const&
); in that case, this constructor
has no effect.
optional<T> uninit ; assert (!uninit); optional<T> uinit2 ( uninit ) ; assert ( uninit2 == uninit ); optional<T> init( T(2) ); assert ( *init == T(2) ) ; optional<T> init2 ( init ) ; assert ( init2 == init ) ;
optional<T>::optional( optional&& rhs ) noexcept(see below);
is_move_constructible<T>::value
is true.
optional.
rhs
is initialized, *this
is initialized and its value is move constructed from rhs; else *this is uninitialized.
T::T( T&& )
throws.
noexcept is equivalent to is_nothrow_move_constructible<T>::value.
rhs
is initialized, T::T( T &&
) is called.
T::T( T&& );
in that case, rhs remains
initialized and the value of *rhs is determined by exception safety
of T::T(T&&).
optional<std::unique_ptr<T>> uninit ; assert (!uninit); optional<std::unique_ptr<T>> uinit2 ( std::move(uninit) ) ; assert ( uninit2 == uninit ); optional<std::unique_ptr<T>> init( std::uniqye_ptr<T>(new T(2)) ); assert ( **init == T(2) ) ; optional<std::unique_ptr<T>> init2 ( std::move(init) ) ; assert ( init ); assert ( *init == nullptr ); assert ( init2 ); assert ( **init2 == T(2) ) ;
template<U> explicit optional<T>::optional( optional<U> const& rhs );
optional.
rhs
is initialized, *this
is initialized and its value is a copy of the
value of rhs converted to type T;
else *this
is uninitialized.
T::T( U const&
) throws.
T::T( U const&
) is called if rhs is initialized, which requires
a valid conversion from U
to T.
T::T( U const&
); in that case, this constructor
has no effect.
optional<double> x(123.4); assert ( *x == 123.4 ) ; optional<int> y(x) ; assert( *y == 123 ) ;
template<U> explicit optional<T>::optional( optional<U>&& rhs );
optional.
rhs
is initialized, *this
is initialized and its value is move-constructed from *rhs;
else *this
is uninitialized.
T::T( U&& )
throws.
T::T( U&& )
is called if rhs is
initialized, which requires a valid conversion from U
to T.
T::T( U&& );
in that case, rhs remains
initialized and the value of *rhs is determined by exception safety
guarantee of T::T( U&&
).
optional<double> x(123.4); assert ( *x == 123.4 ) ; optional<int> y(std::move(x)) ; assert( *y == 123 ) ;
template<InPlaceFactory> explicit optional<T>::optional( InPlaceFactory const& f );
template<TypedInPlaceFactory> explicit optional<T>::optional( TypedInPlaceFactory const& f );
optional with a value of T obtained from the factory.
*this is initialized
and its value is directly given from the factory
f (i.e., the value
is not copied).
T constructor called by the factory
throws.
T
constructor used by the factory; in that case, this constructor has
no effect.
class C { C ( char, double, std::string ) ; } ; C v('A',123.4,"hello"); optional<C> x( in_place ('A', 123.4, "hello") ); // InPlaceFactory used optional<C> y( in_place<C>('A', 123.4, "hello") ); // TypedInPlaceFactory used assert ( *x == v ) ; assert ( *y == v ) ;
optional& optional<T>::operator= ( none_t ) noexcept;
*this is initialized destroys its contained
value.
*this is uninitialized.
optional& optional<T>::operator= ( T const& rhs ) ;
rhs to an optional.
*this is initialized and its value is
a copy of rhs.
T::operator=( T const&
) or T::T(T const&)
throws.
*this was initialized, T's assignment operator is used,
otherwise, its copy-constructor is used.
*this is unchanged and its value unspecified
as far as optional
is concerned (it is up to T's
operator=()).
If *this
is initially uninitialized and T's
copy constructor fails, *this is left properly uninitialized.
T x; optional<T> def ; optional<T> opt(x) ; T y; def = y ; assert ( *def == y ) ; opt = y ; assert ( *opt == y ) ;
optional& optional<T>::operator= ( T&& rhs ) ;
rhs to an optional.
*this is initialized and its value is
moved from rhs.
T::operator=( T&& )
or T::T(T &&)
throws.
*this was initialized, T's move-assignment operator is used,
otherwise, its move-constructor is used.
*this is unchanged and its value unspecified
as far as optional
is concerned (it is up to T's
operator=()).
If *this
is initially uninitialized and T's
move constructor fails, *this is left properly uninitialized.
T x; optional<T> def ; optional<T> opt(x) ; T y1, y2, yR; def = std::move(y1) ; assert ( *def == yR ) ; opt = std::move(y2) ; assert ( *opt == yR ) ;
optional& optional<T>::operator= ( optional const& rhs ) ;
T
is CopyConstructible and CopyAssignable.
Effects:
|
|
|
|
|
|
assigns |
initializes the contained value as if direct-initializing
an object of type |
|
|
destroys the contained value by calling |
no effect |
*this;
bool(rhs) == bool(*this).
*this and rhs
remains unchanged. If an exception is thrown during the call to T's copy constructor, no effect.
If an exception is thrown during the call to T's
copy assignment, the state of its contained value is as defined by
the exception safety guarantee of T's
copy assignment.
T v; optional<T> opt(v); optional<T> def ; opt = def ; assert ( !def ) ; // previous value (copy of 'v') destroyed from within 'opt'.
optional& optional<T>::operator= ( optional&& rhs ) noexcept(see below);
T
is MoveConstructible
and MoveAssignable.
Effects:
|
|
|
|
|
|
assigns |
initializes the contained value as if direct-initializing
an object of type |
|
|
destroys the contained value by calling |
no effect |
*this;
bool(rhs) == bool(*this).
noexcept is equivalent to is_nothrow_move_constructible<T>::value &&
is_nothrow_move_assignable<T>::value.
*this and rhs
remains unchanged. If an exception is thrown during the call to T's move constructor, the state of
*rhs
is determined by the exception safety guarantee of T's
move constructor. If an exception is thrown during the call to T's
move-assignment, the state of **this and *rhs is determined by the exception
safety guarantee of T's move assignment.
optional<T> opt(T(2)) ; optional<T> def ; opt = def ; assert ( def ) ; assert ( opt ) ; assert ( *opt == T(2) ) ;
template<U> optional& optional<T>::operator= ( optional<U> const& rhs ) ;
Effect:
|
|
|
|
|
|
assigns |
initializes the contained value as if direct-initializing
an object of type |
|
|
destroys the contained value by calling |
no effect |
*this.
bool(rhs) == bool(*this).
bool(*this) remains unchanged. If an exception
is thrown during the call to T's
constructor, no effect. If an exception is thrown during the call to
T's assignment, the
state of its contained value is as defined by the exception safety
guarantee of T's copy
assignment.
T v; optional<T> opt0(v); optional<U> opt1; opt1 = opt0 ; assert ( *opt1 == static_cast<U>(v) ) ;
template<U> optional& optional<T>::operator= ( optional<U>&& rhs ) ;
Effect:
|
|
|
|
|
|
assigns |
initializes the contained value as if direct-initializing
an object of type |
|
|
destroys the contained value by calling |
no effect |
*this.
bool(rhs) == bool(*this).
bool(*this) remains unchanged. If an exception
is thrown during the call to T's
constructor, no effect. If an exception is thrown during the call to
T's assignment, the
state of its contained value is as defined by the exception safety
guarantee of T's copy
assignment.
T v; optional<T> opt0(v); optional<U> opt1; opt1 = std::move(opt0) ; assert ( opt0 ); assert ( opt1 ) assert ( *opt1 == static_cast<U>(v) ) ;
template<class... Args> void optional<T>::emplace( Args...&& args );
*this is initialized calls *this = none.
Then initializes in-place the contained value as if direct-initializing
an object of type T
with std::forward<Args>(args)....
*this is initialized.
T's constructor throws.
T,
*this
is uninitialized.
T
need not be MoveConstructible
or MoveAssignable.
On compilers that do not support variadic templates, the signature
falls back to two overloads:template<class
Arg>
void emplace(Arg&& arg) and void
emplace().
On compilers that do not support rvalue references, the signature falls
back to three overloads: taking const
and non-const lvalue reference,
and third with empty function argument list.
T v; optional<const T> opt; opt.emplace(0); // create in-place using ctor T(int) opt.emplace(); // destroy previous and default-construct another T opt.emplace(v); // destroy and copy-construct in-place (no assignment called)
template<InPlaceFactory> optional<T>& optional<T>::operator=( InPlaceFactory const& f );
template<TypedInPlaceFactory> optional<T>& optional<T>::operator=( TypedInPlaceFactory const& f );
optional
with a value of T obtained
from the factory.
*this is initialized
and its value is directly given from the factory
f (i.e., the value
is not copied).
T constructor called by the factory
throws.
T
constructor used by the factory; in that case, the optional
object will be reset to be uninitialized.
void optional<T>::reset( T const& v ) ;
operator=
( T
const&
v)
;
void optional<T>::reset() noexcept ;
operator=(
none_t );
T const& optional<T>::get() const ;
T& optional<T>::get() ;
inline T const& get ( optional<T> const& ) ;
inline T& get ( optional<T> &) ;
*this is initialized
BOOST_ASSERT().
T const& optional<T>::operator*() const& ;
T& optional<T>::operator*() &;
*this is initialized
BOOST_ASSERT().
On compilers that do not support ref-qualifiers on member functions
these two overloads are replaced with the classical two: a const and non-const
member functions.
T v ; optional<T> opt ( v ); T const& u = *opt; assert ( u == v ) ; T w ; *opt = w ; assert ( *opt == w ) ;
T&& optional<T>::operator*() &&;
*this contains a value.
return std::move(*val);.
BOOST_ASSERT().
On compilers that do not support ref-qualifiers on member functions
this overload is not present.
T const& optional<T>::value() const& ;
T& optional<T>::value() & ;
return bool(*this) ? *val : throw bad_optional_access();.
const
and non-const member functions.
T v ; optional<T> o0, o1 ( v ); assert ( o1.value() == v ); try { o0.value(); // throws assert ( false ); } catch(bad_optional_access&) { assert ( true ); }
T&& optional<T>::value() && ;
return bool(*this) ? std::move(*val) : throw bad_optional_access();.
template<class U> T optional<T>::value_or(U && v) const& ;
if (*this) return **this; else return
std::forward<U>(v);.
T
is not CopyConstructible or U &&
is not convertible to T,
the program is ill-formed.
const-qualified member
function. On compilers without rvalue reference support the type of
v becomes U const&.
template<class U> T optional<T>::value_or(U && v) && ;
if (*this) return std::move(**this); else return std::forward<U>(v);.
T
is not MoveConstructible
or U &&
is not convertible to T,
the program is ill-formed.
template<class F> T optional<T>::value_or_eval(F f) const& ;
T
is CopyConstructible and F models a Generator whose result type
is convertible to T.
if
(*this) return **this; else return f();.
const-qualified member
function.
int complain_and_0() { clog << "no value returned, using default" << endl; return 0; } optional<int> o1 = 1; optional<int> oN = none; int i = o1.value_or_eval(complain_and_0); // fun not called assert (i == 1); int j = oN.value_or_eval(complain_and_0); // fun called assert (i == 0);
template<class F> T optional<T>::value_or_eval(F f) && ;
T
is MoveConstructible
and F models a Generator
whose result type is convertible to T.
if
(*this) return std::move(**this); else return
f();.
T const& optional<T>::get_value_or( T const& default) const ;
T& optional<T>::get_value_or( T& default ) ;
value_or() instead.
default.
T v, z ; optional<T> def; T const& y = def.get_value_or(z); assert ( y == z ) ; optional<T> opt ( v ); T const& u = opt.get_value_or(z); assert ( u == v ) ; assert ( u != z ) ;
T const* optional<T>::get_ptr() const ;
T* optional<T>::get_ptr() ;
*this is initialized, a pointer to the
contained value; else 0
(null).
*this,
so you should not hold nor delete this pointer
T v; optional<T> opt(v); optional<T> const copt(v); T* p = opt.get_ptr() ; T const* cp = copt.get_ptr(); assert ( p == get_pointer(opt) ); assert ( cp == get_pointer(copt) ) ;
T const* optional<T>::operator ->() const ;
T* optional<T>::operator ->() ;
*this is initialized.
BOOST_ASSERT().
struct X { int mdata ; } ; X x ; optional<X> opt (x); opt->mdata = 2 ;
explicit optional<T>::operator bool() const noexcept ;
get_ptr() != 0.
optional<T> def ; assert ( def == 0 ); optional<T> opt ( v ) ; assert ( opt ); assert ( opt != 0 );
bool optional<T>::operator!() noexcept ;
*this is uninitialized, true; else false.
optional<T> opt ; assert ( !opt ); *opt = some_T ; // Notice the "double-bang" idiom here. assert ( !!opt ) ;
bool optional<T>::is_initialized() const ;
explicit operator
bool ()
;