std::optional<T>:: operator=
From cppreference.com
|
optional
&
operator
=
(
std::
nullopt_t
)
noexcept
;
|
(1) |
(since C++17)
(constexpr since C++20) |
|
constexpr
optional
&
operator
=
(
const
optional
&
other
)
;
|
(2) | (since C++17) |
|
constexpr
optional
&
operator
=
(
optional
&&
other
)
noexcept
(
/* see below */
)
;
|
(3) | (since C++17) |
|
template
<
class
U
=
T
>
optional & operator = ( U && value ) ; |
(4) |
(since C++17)
(constexpr since C++20) |
|
template
<
class
U
>
optional & operator = ( const optional < U > & other ) ; |
(5) |
(since C++17)
(constexpr since C++20) |
|
template
<
class
U
>
optional & operator = ( optional < U > && other ) ; |
(6) |
(since C++17)
(constexpr since C++20) |
Replaces contents of * this with the contents of other .
1)
If
*
this
contains a value before the call, the contained value is destroyed by calling its destructor as if by
value
(
)
.
T
::
~T
(
)
.
*
this
does not contain a value after this call.
2,3)
Assigns the state of
other
.
- If both * this and other do not contain a value, the function has no effect.
- If * this contains a value, but other does not, then the contained value is destroyed by calling its destructor. * this does not contain a value after the call.
- If other contains a value, then depending on whether * this contains a value, the contained value is either direct-initialized or assigned from * other (2) or std :: move ( * other ) (3) . Note that a moved-from optional still contains a value .
- Overload (2) is deleted when either std:: is_copy_constructible_v < T > or std:: is_copy_assignable_v < T > is false . It is trivial if std:: is_trivially_copy_constructible_v < T > , std:: is_trivially_copy_assignable_v < T > and std:: is_trivially_destructible_v < T > are all true .
- Overload (3) does not participate in overload resolution when either std:: is_move_constructible_v < T > or std:: is_move_assignable_v < T > is false . It is trivial if std:: is_trivially_move_constructible_v < T > , std:: is_trivially_move_assignable_v < T > and std:: is_trivially_destructible_v < T > are all true .
4)
Perfect-forwarded assignment: depending on whether
*
this
contains a value before the call, the contained value is either direct-initialized from
std::
forward
<
U
>
(
value
)
or assigned from
std::
forward
<
U
>
(
value
)
. The function does not participate in overload resolution unless
std::
decay_t
<
U
>
(until C++20)
std::
remove_cvref_t
<
U
>
(since C++20)
is not
std::
optional
<
T
>
,
std::
is_constructible_v
<
T, U
>
is
true
,
std::
is_assignable_v
<
T
&
, U
>
is
true
, and at least one of the following is true:
-
Tis not a scalar type ; -
std::
decay_t
<
U
>
is not
T.
5,6)
Assigns the state of
other
.
- If both * this and other do not contain a value, the function has no effect.
- If * this contains a value, but other does not, then the contained value is destroyed by calling its destructor. * this does not contain a value after the call.
- If other contains a value, then depending on whether * this contains a value, the contained value is either direct-initialized or assigned from * other (5) or std :: move ( * other ) (6) . Note that a moved-from optional still contains a value .
-
These overloads do not participate in overload resolution unless the following conditions are met:
-
Tis not constructible, convertible, or assignable from any expression of type (possibly const ) std:: optional < U > , i.e., the following 12 type traits are all false :- std:: is_constructible_v < T, std:: optional < U > & >
- std:: is_constructible_v < T, const std:: optional < U > & >
- std:: is_constructible_v < T, std:: optional < U > && >
- std:: is_constructible_v < T, const std:: optional < U > && >
- std:: is_convertible_v < std:: optional < U > & , T >
- std:: is_convertible_v < const std:: optional < U > & , T >
- std:: is_convertible_v < std:: optional < U > && , T >
- std:: is_convertible_v < const std:: optional < U > && , T >
- std:: is_assignable_v < T & , std:: optional < U > & >
- std:: is_assignable_v < T & , const std:: optional < U > & >
- std:: is_assignable_v < T & , std:: optional < U > && >
- std:: is_assignable_v < T & , const std:: optional < U > && >
- For overload (5) , std:: is_constructible_v < T, const U & > and std:: is_assignable_v < T & , const U & > are both true .
- For overload (6) , std:: is_constructible_v < T, U > and std:: is_assignable_v < T & , U > are both true .
-
Parameters
| other | - |
another
optional
object whose contained value to assign
|
| value | - | value to assign to the contained value |
Return value
* this
Exceptions
2-6)
Throws any exception thrown by the constructor or assignment operator of
T
. If an exception is thrown, the initialization state of
*
this
(and of
other
in case of
(
2,3
)
and
(
5,6
)
) is unchanged, i.e. if the object contained a value, it still contains a value, and the other way round. The contents of
value
and the contained values of
*
this
and
other
depend on the exception safety guarantees of the operation from which the exception originates (copy-constructor, move-assignment, etc.).
3)
Has following
noexcept
specification:
noexcept
(
std::
is_nothrow_move_assignable_v
<
T
>
&&
std::
is_nothrow_move_constructible_v
<
T
>
)
Notes
An optional object
op
may be turned into an empty optional with both
op
=
{
}
;
and
op
=
nullopt
;
. The first expression constructs an empty
optional
object with
{
}
and assigns it to
op
.
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_optional
|
202106L |
(C++20)
(DR20) |
Fully constexpr ( 1 ) , ( 4-6 ) |
Example
Run this code
#include <iostream> #include <optional> int main() { std::optional<const char*> s1 = "abc", s2; // constructor s2 = s1; // assignment s1 = "def"; // decaying assignment (U = char[4], T = const char*) std::cout << *s2 << ' ' << *s1 << '\n'; }
Output:
abc def
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| P0602R4 | C++17 |
copy/move assignment operator may not be trivial
even if underlying operations are trivial |
required to propagate triviality |
| P2231R1 | C++20 |
converting assignment operators
(
1
)
and
(
4-6
)
were not
constexpr
while the required operations can be in C++20 |
made constexpr |
See also
|
constructs the contained value in-place
(public member function) |