Home | Libraries | People | FAQ | More |
optional<T&>::optional() noexcept;
optional<T&>::optional(none_t) noexcept;
bool(*this) == false
; *this
refers to nothing.
template<class R> optional<T&>::optional(R&& r) noexcept;
bool(*this) == true
; addressof(**this) == addressof(r)
.
R
is an lvalue reference, the program is ill-formed. This constructor
does not participate in overload resolution if decay<R>
is an instance of boost::optional
.
explicit
on compilers
that do not correctly suport binding to const lvalues of integral types.
For more details see here.
T v; T& vref = v ; optional<T&> opt(vref); assert ( *opt == v ) ; ++ v ; // mutate referee assert (*opt == v);
template<class R> optional<T&>::optional(bool cond, R&& r) noexcept;
ref
with expression cond ?
addressof(r) : nullptr
.
bool(*this) == cond
; If bool(*this)
, addressof(**this) == addressof(r)
.
R
is an lvalue reference, the program is ill-formed. This constructor
does not participate in overload resolution if decay<R>
is an instance of boost::optional
.
optional<T&>::optional ( optional const& rhs ) noexcept ;
ref
with expression rhs.ref
.
bool(*this) == bool(rhs)
.
optional<T&> uninit ; assert (!uninit); optional<T&> uinit2 ( uninit ) ; assert ( uninit2 == uninit ); T v = 2 ; T& ref = v ; optional<T> init(ref); assert ( *init == v ) ; optional<T> init2 ( init ) ; assert ( *init2 == v ) ; v = 3 ; assert ( *init == 3 ) ; assert ( *init2 == 3 ) ;
template<class U> explicit optional<T&>::optional ( optional<U&> const& rhs ) noexcept ;
is_convertible<U&, T&>::value
is true
.
ref
with expression rhs.ref
.
bool(*this) == bool(rhs)
.
optional<T&>::operator= ( none_t ) noexcept ;
ref
with expression nullptr
.
*this
.
bool(*this) == false
.
optional& optional<T&>::operator= ( optional const& rhs ) noexcept ;
ref
with expression rhs.ref
.
*this
.
bool(*this) == bool(rhs)
.
int a = 1 ; int b = 2 ; T& ra = a ; T& rb = b ; optional<int&> def ; optional<int&> ora(ra) ; optional<int&> orb(rb) ; def = orb ; // binds 'def' to 'b' through 'rb' wrapped within 'orb' assert ( *def == b ) ; *def = ora ; // changes the value of 'b' to a copy of the value of 'a' assert ( b == a ) ; int c = 3; int& rc = c ; optional<int&> orc(rc) ; ora = orc ; // REBINDS ora to 'c' through 'rc' c = 4 ; assert ( *ora == 4 ) ;
template<class U> optional& optional<T&>::operator= ( optional<U&> const& rhs ) noexcept ;
is_convertible<U&, T&>::value
is true
.
ref
with expression rhs.ref
.
*this
.
bool(*this) == bool(rhs)
.
template<class R> optional& optional<T&>::operator= ( R&& r ) noexcept ;
ref
with expression r
.
*this
.
bool(*this) == true
.
R
is an lvalue reference, the program is ill-formed. This function does
not participate in overload resolution if decay<R>
is an instance of boost::optional
.
int a = 1 ; int b = 2 ; T& ra = a ; T& rb = b ; optional<int&> def ; optional<int&> opt(ra) ; def = rb ; // binds 'def' to 'b' through 'rb' assert ( *def == b ) ; *def = a ; // changes the value of 'b' to a copy of the value of 'a' assert ( b == a ) ; int c = 3; int& rc = c ; opt = rc ; // REBINDS to 'c' through 'rc' c = 4 ; assert ( *opt == 4 ) ;
void optional<T&>::emplace( R&& r ) noexcept ;
ref
with expression r
.
bool(*this) == true
.
R
is an lvalue reference, the program is ill-formed. This function does
not participate in overload resolution if decay<R>
is an instance of boost::optional
.
T& optional<T&>::get() const ;
T& optional<T&>::operator *() const ;
bool(*this) == true
.
*ref
.
T v ; T& vref = v ; optional<T&> opt ( vref ); T const& vref2 = *opt; assert ( vref2 == v ) ; ++ v ; assert ( *opt == v ) ;
T* optional<T&>::operator -> () const ;
bool(*this) == true
.
ref
.
T& optional<T&>::value() const ;
return bool(*this) ? *val : throw bad_optional_access();
.
template<class R> T& optional<T&>::value_or( R&& r ) const noexcept;
if (*this) return **this; else return
r;
.
R
is an lvalue reference, the program is ill-formed.
template<class F> T& optional<T&>::value_or( F f ) const ;
if (*this) return **this; else return
f();
.
decltype(f())
is an lvalue reference, the program
is ill-formed.
template<class F> auto optional<T&>::map( F f ) const ->
see below;
if (*this) return f(**this); else return none;
.
optional<decltype(f(**this))>
.
template<class F> auto optional<T&>::flat_map( F f ) const ->
see below;
f(**this)
is optional<U>
for some object or reference type U
.
if (*this) return f(**this); else return none;
.
optional<U>
.
T* optional<T&>::get_ptr () const noexcept;
ref
.
bool has_value() const noexcept;
optional<T&>::operator bool () const noexcept;
bool(ref)
.
optional<T&>::operator ! () const noexcept;
!bool(ref)
.
void optional<T&>::reset() noexcept;
*this = none
.
template<class R> void optional<T&>::reset ( R&& r) noexcept;
*this = std::forward<R>(r)
.
bool optional<T&>::is_initialized() const noexcept;
return bool(*this)
.
template<class R> T& optional<T&>::get_value_or( R&& r ) const noexcept;
return value_or(std::forward<R>(r);
.