-
optional<T>::optional();+optional<T>::optional() noexcept;
*this is uninitialized.
-
optional<T>::optional( none_t );+optional<T>::optional( none_t ) noexcept;
*this is uninitialized.
T's
default constructor is not called.
@@ -132,12 +125,16 @@
optional<T (not a ref)>::optional( T const& v )
is_copy_constructible<T>::value
+ is true.
+ optional.
*this is initialized
- and its value is acopy of v.
+ and its value is a copy of v.
T::T(
@@ -193,6 +190,58 @@
+
+
+
optional<T(not a ref)>::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( T&& ref ) = delete+
optional<T (not a ref)>::optional( optional const& rhs );
is_copy_constructible<T>::value
+ is true.
+ optional.
+
+
+
optional<T(not a ref)>::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.
+ rhs
+ is initialized, T::T( T
+ && )
+ is called. The expression inside noexcept
+ is equivalent to is_nothrow_move_constructible<T>::value.
+ 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) ) ; ++
+
+
+
optional<T&>::optional( optional && + rhs );+
optional.
+ rhs
+ is initialized, *this
+ is initialized and its value is another reference to the same object referenced
+ by *rhs;
+ else *this
+ is uninitialized.
+ rhs
+ is initialized, both *this
+ and *rhs
+ will reefer to the same object (they alias).
+ optional<std::unique_ptr<T>&> uninit ; +assert (!uninit); + +optional<std::unique_ptr<T>&> uinit2 ( std::move(uninit) ) ; +assert ( uninit2 == uninit ); + +std::unique_ptr<T> v(new T(2)) ; +optional<std::unique_ptr<T>&> init(v); +assert ( *init == v ) ; + +optional<std::unique_ptr<T>&> init2 ( std::move(init) ) ; +assert ( *init2 == v ) ; + +*v = 3 ; + +assert ( **init == 3 ) ; +assert ( **init2 == 3 ) ; ++
+
+
+
template<U> explicit optional<T+ (not a ref)>::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 ) ; ++
+
+
+
optional& + optional<T(not a ref)>::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<T&>& + optional<T&>::operator= ( T&& + rhs ) + = delete;+
+
+
+
optional& + optional<T(not a ref)>::operator= ( optional&& rhs + ) noexcept(see below);+
optional to an optional.
+ rhs
+ is initialized, *this
+ is initialized and its value is moved from *rhs, rhs
+ remains initialized; else *this is uninitialized.
+ T::operator( T&&
+ ) or T::T(
+ T &&
+ ) throws.
+ *this and rhs
+ are initially initialized, T's
+ move assignment operator is used. If *this is
+ initially initialized but rhs
+ is uninitialized, T's [destructor]
+ is called. If *this
+ is initially uninitialized but rhs
+ is initialized, T's move
+ constructor is called. The expression inside noexcept
+ is equivalent to is_nothrow_move_constructible<T>::value
+ && is_nothrow_move_assignable<T>::value.
+ *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.
+ optional<T> opt(T(2)) ; +optional<T> def ; + +opt = def ; +assert ( def ) ; +assert ( opt ) ; +assert ( *opt == T(2) ) ; ++
+
+
+
optional<T&> & optional<T&>::operator= ( optional<T&>&& + rhs ) + ;+
optional<T&>::operator= ( optional<T&> const& rhs ).
+
+
+
+
template<U> optional& + optional<T(not a ref)>::operator= ( optional<U>&& + rhs ) + ;+
rhs
+ is initialized, *this
+ is initialized and its value is moved from the value of rhs;
+ else *this
+ is uninitialized.
+ T::operator=( U&& )
+ or T::T( U&& )
+ throws.
+ *this and rhs
+ are initially initialized, T's
+ assignment operator (from U&&) is used. If *this is initially initialized but rhs is uninitialized, T's
+ destructor is called. If *this is initially uninitialized but rhs is initialized, T's
+ converting constructor (from U&&) is called.
+ *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
+ converting constructor fails, *this is left properly uninitialized.
+ T v; +optional<T> opt0(v); +optional<U> opt1; + +opt1 = std::move(opt0) ; +assert ( *opt1 == static_cast<U>(v) ) ; ++
*this is initialized
+ Requires: *this is initialized
*this is initialized
+ Requires: *this is initialized
*this is initialized.
+ Requires: *this is initialized.
-
bool optional<T>::operator!() ;+bool optional<T>::operator!() noexcept ;
*this is uninitialized, true;
else false.
void swap ( optional<T>& - x, optional<T>& y );+ x, optional<T>& y ) ;
swap(T&,T&)
- throws. If only one is initialized, whatever T::T ( T const& ) throws.
+ throws. If only one is initialized, whatever T::T ( T&&
+ ) throws.
swap(T&,T&)
is used unqualified but with std::swap
introduced in scope. If only one is initialized, T::~T() and T::T(
- T const& )
- is called.
+ T&&
+ ) is called.
swap(T&,T&).
- If only one is initialized, it has the same basic guarantee as optional<T>::reset( T const& ).
+ If only one is initialized, it has the same basic guarantee as optional<T>::operator= ( T&&
+ ).
+ Rvalue references and lvalue references to const have the ability in C++ to + extend the life time of a temporary they bind to. Optional references do not + have this capability, therefore to avoid surprising effects it is not possible + to initialize an optional references from a temporary. Optional rvalue references + are disabled altogether. Also, the initialization and assignment of an optional + reference to const from rvalue reference is disabled. +
+const int& i = 1; // legal +optional<const int&> oi = 1; // illegal +
| diff --git a/doc/html/boost_optional/synopsis.html b/doc/html/boost_optional/synopsis.html index 802fa02..8ce8e1f 100644 --- a/doc/html/boost_optional/synopsis.html +++ b/doc/html/boost_optional/synopsis.html @@ -37,19 +37,25 @@ // (If T is of reference type, the parameters and results by reference are by value) - optional () ; |
Last revised: April 26, 2014 at 08:58:33 GMT |
+Last revised: April 28, 2014 at 23:21:56 GMT |
