Because <codeclass="computeroutput"><spanclass="identifier">T</span></code> might be of reference
type, in the sequel, those entries whose semantic depends on <codeclass="computeroutput"><spanclass="identifier">T</span></code> being of reference type or not will be
If the entry reads: <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not
a ref)</em></span><codeclass="computeroutput"><spanclass="special">></span></code>, the
description corresponds only to the case where <codeclass="computeroutput"><spanclass="identifier">T</span></code>
is not of reference type.
</li>
<liclass="listitem">
If the entry reads: <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">&></span></code>, the description corresponds
only to the case where <codeclass="computeroutput"><spanclass="identifier">T</span></code>
is of reference type.
</li>
<liclass="listitem">
If the entry reads: <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">></span></code>, the description is the same for
The following section contains various <codeclass="computeroutput"><spanclass="identifier">assert</span><spanclass="special">()</span></code> which are used only to show the postconditions
as sample code. It is not implied that the type <codeclass="computeroutput"><spanclass="identifier">T</span></code>
must support each particular expression but that if the expression is supported,
<spanclass="bold"><strong>Effect:</strong></span> Default-Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">uninitialized</span>.
<spanclass="bold"><strong>Effect:</strong></span> Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code> uninitialized.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">uninitialized</span>.
The expression <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">none</span></code>
denotes an instance of <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">none_t</span></code>
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">v</span><spanclass="special">)</span></code>
is <codeclass="computeroutput"><spanclass="keyword">true</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Effect:</strong></span> Directly-Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">initialized</span>
and its value is a <spanclass="emphasis"><em>copy</em></span> of <codeclass="computeroutput"><spanclass="identifier">v</span></code>.
<spanclass="bold"><strong>Notes: </strong></span><codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code> is called.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">);</span></code>
<spanclass="bold"><strong>Effect:</strong></span> Directly-Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">initialized</span>
and its value is an instance of an internal type wrapping the reference
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&</span>
<spanclass="bold"><strong>Postconditions:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">initialized</span>
and its value is move-constructed from <codeclass="computeroutput"><spanclass="identifier">v</span></code>.
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&</span>
<spanclass="special">);</span></code> in that case, the state of
<codeclass="computeroutput"><spanclass="identifier">v</span></code> is determined by exception
safety guarantees for <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&)</span></code>.
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="keyword">bool</span><spanclass="identifier">condition</span><spanclass="special">,</span>
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">v</span><spanclass="special">)</span></code>
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">()</span></code>
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">optional</span>
is initialized and its value is a <spanclass="emphasis"><em>copy</em></span> of the value
of <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>; else <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
<spanclass="bold"><strong>Notes:</strong></span> If rhs is initialized, <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code>
is called.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">);</span></code>
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">optional</span><spanclass="special">&&</span><spanclass="identifier">rhs</span>
<spanclass="bold"><strong>Remarks:</strong></span> The expression inside <codeclass="computeroutput"><spanclass="keyword">noexcept</span></code> is equivalent to <codeclass="computeroutput"><spanclass="identifier">is_nothrow_move_constructible</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">>::</span><spanclass="identifier">value</span></code>.
<spanclass="bold"><strong>Notes:</strong></span> If <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
is initialized, <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&</span>
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&</span>
<spanclass="special">);</span></code> in that case, <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> remains initialized and the value
of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code>
is determined by exception safety of <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&)</span></code>.
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">U</span><spanclass="special">></span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">rhs</span><spanclass="special">);</span></code>
<spanclass="bold"><strong>Notes: </strong></span><codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">U</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code> is called if <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
is initialized, which requires a valid conversion from <codeclass="computeroutput"><spanclass="identifier">U</span></code> to <codeclass="computeroutput"><spanclass="identifier">T</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">U</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">);</span></code>
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">U</span><spanclass="special">>&&</span>
is initialized and its value is move-constructed from <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code>; else <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is uninitialized.
is called if <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> is initialized,
which requires a valid conversion from <codeclass="computeroutput"><spanclass="identifier">U</span></code>
to <codeclass="computeroutput"><spanclass="identifier">T</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">U</span><spanclass="special">&&</span>
<spanclass="special">);</span></code> in that case, <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> remains initialized and the value
of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code>
is determined by exception safety guarantee of <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">U</span><spanclass="special">&&</span><spanclass="special">)</span></code>.
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">InPlaceFactory</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">f</span><spanclass="special">);</span></code>
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">optional</span><spanclass="special">(</span><spanclass="identifier">TypedInPlaceFactory</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">f</span><spanclass="special">);</span></code>
<spanclass="bold"><strong>Effect:</strong></span> Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code> with a value of <codeclass="computeroutput"><spanclass="identifier">T</span></code> obtained from the factory.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">initialized</span>
and its value is <spanclass="emphasis"><em>directly given</em></span> from the factory
<codeclass="computeroutput"><spanclass="identifier">f</span></code> (i.e., the value <spanclass="underline">is not copied</span>).
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> Whatever the <codeclass="computeroutput"><spanclass="identifier">T</span></code>
constructor called by the factory throws.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> See <aclass="link"href="../tutorial/in_place_factories.html"title="In-Place Factories">In-Place
Factories</a>
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during the call to the <codeclass="computeroutput"><spanclass="identifier">T</span></code>
constructor used by the factory; in that case, this constructor has no
<spanclass="bold"><strong>Effect:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized destroys its contained
value.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is uninitialized.
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">T</span>
<spanclass="bold"><strong>Effect:</strong></span> Assigns the value <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> to an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized and its value is a
<spanclass="emphasis"><em>copy</em></span> of <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> Whatever <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="keyword">operator</span><spanclass="special">=(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code> or <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&)</span></code>
throws.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> was initialized, <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
assignment operator is used, otherwise, its copy-constructor is used.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> In the event of an
exception, the initialization state of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is unchanged and its value unspecified
as far as <codeclass="computeroutput"><spanclass="identifier">optional</span></code> is
concerned (it is up to <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initially uninitialized and <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="emphasis"><em>copy constructor</em></span> fails, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is left properly uninitialized.
<spanclass="bold"><strong>Effect:</strong></span> (Re)binds the wrapped reference.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized and it references
the same object referenced by <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> was initialized, it is <spanclass="emphasis"><em>rebound</em></span>
to the new object. See <aclass="link"href="../tutorial/rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">here</a>
<spanclass="identifier">def</span><spanclass="special">=</span><spanclass="identifier">rb</span><spanclass="special">;</span><spanclass="comment">// binds 'def' to 'b' through 'rb'</span>
<spanclass="special">*</span><spanclass="identifier">def</span><spanclass="special">=</span><spanclass="identifier">a</span><spanclass="special">;</span><spanclass="comment">// changes the value of 'b' to a copy of the value of 'a'</span>
<spanclass="identifier">opt</span><spanclass="special">=</span><spanclass="identifier">rc</span><spanclass="special">;</span><spanclass="comment">// REBINDS to 'c' through 'rc'</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&</span><spanclass="identifier">rhs</span>
<spanclass="bold"><strong>Effect:</strong></span> Moves the value <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> to an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized and its value is moved
from <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>.
or <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&)</span></code>
throws.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> was initialized, <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
move-assignment operator is used, otherwise, its move-constructor is
used.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> In the event of an
exception, the initialization state of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is unchanged and its value unspecified
as far as <codeclass="computeroutput"><spanclass="identifier">optional</span></code> is
concerned (it is up to <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initially uninitialized and <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="emphasis"><em>move constructor</em></span> fails, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is left properly uninitialized.
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">optional</span>
is <ahref="../../../../../utility/CopyConstructible.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">CopyConstructible</span></code></a> and <codeclass="computeroutput"><spanclass="identifier">CopyAssignable</span></code>.
If <codeclass="computeroutput"><spanclass="special">!*</span><spanclass="keyword">this</span>
<spanclass="special">&&</span><spanclass="special">!</span><spanclass="identifier">rhs</span></code> no effect, otherwise
</li>
<liclass="listitem">
if <codeclass="computeroutput"><spanclass="keyword">bool</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span>
<spanclass="special">&&</span><spanclass="special">!</span><spanclass="identifier">rhs</span></code>, destroys the contained value
by calling <codeclass="computeroutput"><spanclass="identifier">val</span><spanclass="special">-></span><spanclass="identifier">T</span><spanclass="special">::~</span><spanclass="identifier">T</span><spanclass="special">()</span></code>, otherwise
</li>
<liclass="listitem">
if <codeclass="computeroutput"><spanclass="special">!*</span><spanclass="keyword">this</span>
<spanclass="special">&&</span><spanclass="keyword">bool</span><spanclass="special">(</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code>, initializes the contained value
as if direct-initializing an object of type <codeclass="computeroutput"><spanclass="identifier">T</span></code>
with <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code>,
<spanclass="special">&&</span><spanclass="keyword">bool</span><spanclass="special">(</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code>) assigns <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code> to the contained value.
<spanclass="bold"><strong>Exception Safety:</strong></span> If any exception is
thrown, the initialization state of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> and <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
remains unchanged. If an exception is thrown during the call to <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s copy constructor, no effect. If
an exception is thrown during the call to <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
copy assignment, the state of its contained value is as defined by the
exception safety guarantee of <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="bold"><strong>Effect:</strong></span> (Re)binds thee wrapped reference.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code> is initialized, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized and it references
the same object referenced by <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code>; otherwise, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is uninitialized (and references
no object).
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> was initialized and so is <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code>,
is <spanclass="emphasis"><em>rebound</em></span> to the new object. See <aclass="link"href="../tutorial/rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">here</a>
<spanclass="identifier">def</span><spanclass="special">=</span><spanclass="identifier">orb</span><spanclass="special">;</span><spanclass="comment">// binds 'def' to 'b' through 'rb' wrapped within 'orb'</span>
<spanclass="special">*</span><spanclass="identifier">def</span><spanclass="special">=</span><spanclass="identifier">ora</span><spanclass="special">;</span><spanclass="comment">// changes the value of 'b' to a copy of the value of 'a'</span>
<spanclass="identifier">ora</span><spanclass="special">=</span><spanclass="identifier">orc</span><spanclass="special">;</span><spanclass="comment">// REBINDS ora to 'c' through 'rc'</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">optional</span><spanclass="special">&&</span><spanclass="identifier">rhs</span>
If <codeclass="computeroutput"><spanclass="special">!*</span><spanclass="keyword">this</span>
<spanclass="special">&&</span><spanclass="special">!</span><spanclass="identifier">rhs</span></code> no effect, otherwise
</li>
<liclass="listitem">
if <codeclass="computeroutput"><spanclass="keyword">bool</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span>
<spanclass="special">&&</span><spanclass="special">!</span><spanclass="identifier">rhs</span></code>, destroys the contained value
by calling <codeclass="computeroutput"><spanclass="identifier">val</span><spanclass="special">-></span><spanclass="identifier">T</span><spanclass="special">::~</span><spanclass="identifier">T</span><spanclass="special">()</span></code>, otherwise
</li>
<liclass="listitem">
if <codeclass="computeroutput"><spanclass="special">!*</span><spanclass="keyword">this</span>
<spanclass="special">&&</span><spanclass="keyword">bool</span><spanclass="special">(</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code>, initializes the contained value
as if direct-initializing an object of type <codeclass="computeroutput"><spanclass="identifier">T</span></code>
with <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">move</span><spanclass="special">(*</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code>,
<spanclass="special">&&</span><spanclass="keyword">bool</span><spanclass="special">(</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code>) assigns <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">move</span><spanclass="special">(*</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code> to the contained value.
<spanclass="bold"><strong>Remarks:</strong></span> The expression inside <codeclass="computeroutput"><spanclass="keyword">noexcept</span></code> is equivalent to <codeclass="computeroutput"><spanclass="identifier">is_nothrow_move_constructible</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">>::</span><spanclass="identifier">value</span><spanclass="special">&&</span>
<spanclass="bold"><strong>Exception Safety:</strong></span> If any exception is
thrown, the initialization state of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> and <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
remains unchanged. If an exception is thrown during the call to <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s move constructor, the state of
<spanclass="bold"><strong>Effect:</strong></span> Same as <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">&>::</span><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">&></span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">rhs</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">U</span><spanclass="special">></span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">rhs</span><spanclass="special">)</span><spanclass="special">;</span></code>
<spanclass="bold"><strong>Effect:</strong></span> Assigns another convertible
optional to an optional.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions:</strong></span> If <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
is initialized, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initialized and its value is a <spanclass="emphasis"><em>copy</em></span> of the value
of <codeclass="computeroutput"><spanclass="identifier">rhs</span></code><spanclass="emphasis"><em>converted</em></span>
to type <codeclass="computeroutput"><spanclass="identifier">T</span></code>; else <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is uninitialized.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> Whatever <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="keyword">operator</span><spanclass="special">=(</span><spanclass="identifier">U</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code> or <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">U</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code> throws.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If both <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> and rhs are initially initialized,
is used. If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initially initialized but <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
is uninitialized, <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="emphasis"><em>destructor</em></span> is called. If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initially uninitialized but rhs
is initialized, <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="bold"><strong>Exception Safety:</strong></span> In the event of an
exception, the initialization state of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is unchanged and its value unspecified
as far as optional is concerned (it is up to <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initially uninitialized and <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
converting constructor fails, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is left properly uninitialized.
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">U</span><spanclass="special">>&&</span><spanclass="identifier">rhs</span>
<spanclass="bold"><strong>Effect:</strong></span> Move-assigns another convertible
optional to an optional.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions:</strong></span> If <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
is initialized, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initialized and its value is moved from the value of <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>; else <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is uninitialized.
or <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">U</span><spanclass="special">&&</span>
<spanclass="special">)</span></code> throws.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If both <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> and <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
are initially initialized, <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="emphasis"><em>assignment operator</em></span> (from <codeclass="computeroutput"><spanclass="identifier">U</span><spanclass="special">&&</span></code>) is used. If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initially initialized but <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
is uninitialized, <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="emphasis"><em>destructor</em></span> is called. If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initially uninitialized but <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> is initialized, <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
<spanclass="emphasis"><em>converting constructor</em></span> (from <codeclass="computeroutput"><spanclass="identifier">U</span><spanclass="special">&&</span></code>) is called.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> In the event of an
exception, the initialization state of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is unchanged and its value unspecified
as far as optional is concerned (it is up to <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initially uninitialized and <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s
converting constructor fails, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is left properly uninitialized.
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">emplace</span><spanclass="special">(</span><spanclass="identifier">Args</span><spanclass="special">...&&</span>
<spanclass="bold"><strong>Requires:</strong></span> The compiler supports rvalue
references and variadic templates.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Effect:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized calls <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span><spanclass="special">=</span><spanclass="identifier">none</span></code>.
Then initializes in-place the contained value as if direct-initializing
an object of type <codeclass="computeroutput"><spanclass="identifier">T</span></code> with
<spanclass="bold"><strong>Postconditions: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">initialized</span>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> Whatever the selected <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s constructor throws.
or <codeclass="computeroutput"><spanclass="identifier">MoveAssignable</span></code>. On
compilers that do not support variadic templates, the signature falls
back to single-argument: <codeclass="computeroutput"><spanclass="keyword">template</span><spanclass="special"><</span><spanclass="keyword">class</span><spanclass="identifier">Arg</span><spanclass="special">></span><spanclass="keyword">void</span><spanclass="identifier">emplace</span><spanclass="special">(</span><spanclass="identifier">Arg</span><spanclass="special">&&</span><spanclass="identifier">arg</span><spanclass="special">)</span></code>. On compilers that do not support rvalue
references, the signature falls back to two overloads: taking <codeclass="computeroutput"><spanclass="keyword">const</span></code> and non-<codeclass="computeroutput"><spanclass="keyword">const</span></code>
<spanclass="identifier">opt</span><spanclass="special">.</span><spanclass="identifier">emplace</span><spanclass="special">(</span><spanclass="number">0</span><spanclass="special">);</span><spanclass="comment">// create in-place using ctor T(int)</span>
<spanclass="identifier">opt</span><spanclass="special">.</span><spanclass="identifier">emplace</span><spanclass="special">();</span><spanclass="comment">// destroy previous and default-construct another T</span>
<spanclass="identifier">opt</span><spanclass="special">.</span><spanclass="identifier">emplace</span><spanclass="special">(</span><spanclass="identifier">v</span><spanclass="special">);</span><spanclass="comment">// destroy and copy-construct in-place (no assignment called)</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=(</span><spanclass="identifier">InPlaceFactory</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">=(</span><spanclass="identifier">TypedInPlaceFactory</span>
<spanclass="bold"><strong>Effect:</strong></span> Assigns an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>
with a value of <codeclass="computeroutput"><spanclass="identifier">T</span></code> obtained
from the factory.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Postconditions: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is <spanclass="underline">initialized</span>
and its value is <spanclass="emphasis"><em>directly given</em></span> from the factory
<codeclass="computeroutput"><spanclass="identifier">f</span></code> (i.e., the value <spanclass="underline">is not copied</span>).
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> Whatever the <codeclass="computeroutput"><spanclass="identifier">T</span></code>
constructor called by the factory throws.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> See <aclass="link"href="../tutorial/in_place_factories.html"title="In-Place Factories">In-Place
Factories</a>
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> Exceptions can only
be thrown during the call to the <codeclass="computeroutput"><spanclass="identifier">T</span></code>
constructor used by the factory; in that case, the <codeclass="computeroutput"><spanclass="identifier">optional</span></code>
object will be reset to be <spanclass="emphasis"><em>uninitialized</em></span>.
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">reset</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">v</span><spanclass="special">)</span><spanclass="special">;</span></code>
<spanclass="bold"><strong>Deprecated:</strong></span> same as <codeclass="computeroutput"><spanclass="keyword">operator</span><spanclass="special">=</span><spanclass="special">(</span><spanclass="identifier">T</span>
<spanclass="bold"><strong>Deprecated:</strong></span> Same as <codeclass="computeroutput"><spanclass="keyword">operator</span><spanclass="special">=(</span><spanclass="identifier">none_t</span>
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">get</span><spanclass="special">()</span><spanclass="keyword">const</span><spanclass="special">;</span></code>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">get</span><spanclass="special">()</span><spanclass="special">;</span></code>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">></span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span><spanclass="special">;</span></code>
<spanclass="bold"><strong>Requires:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized
</li>
<liclass="listitem">
<spanclass="bold"><strong>Returns:</strong></span> A reference to the contained
<spanclass="bold"><strong>Requires: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">*()</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">;</span></code>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">*()</span><spanclass="special">&;</span></code>
<spanclass="bold"><strong>Requires:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized
</li>
<liclass="listitem">
<spanclass="bold"><strong>Returns:</strong></span> A reference to the contained
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">*()</span><spanclass="special">&&;</span></code>
<spanclass="bold"><strong>Requires:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> contains a value.
<spanclass="bold"><strong>Effects:</strong></span> Equivalent to <codeclass="computeroutput"><spanclass="keyword">return</span><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">move</span><spanclass="special">(*</span><spanclass="identifier">val</span><spanclass="special">);</span></code>.
<spanclass="bold"><strong>Requires: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized
On compilers that do not support ref-qualifiers on member functions these
three overloads are replaced with the classical two: a <codeclass="computeroutput"><spanclass="keyword">const</span></code> and non-<codeclass="computeroutput"><spanclass="keyword">const</span></code>
<spanclass="bold"><strong>Effects:</strong></span> Equivalent to <codeclass="computeroutput"><spanclass="keyword">return</span><spanclass="keyword">bool</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span><spanclass="special">?</span><spanclass="special">*</span><spanclass="identifier">val</span><spanclass="special">:</span><spanclass="keyword">throw</span><spanclass="identifier">bad_optional_access</span><spanclass="special">();</span></code>.
<spanclass="bold"><strong>Effects:</strong></span> Equivalent to <codeclass="computeroutput"><spanclass="keyword">return</span><spanclass="keyword">bool</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span><spanclass="special">?</span><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">move</span><spanclass="special">(*</span><spanclass="identifier">val</span><spanclass="special">)</span><spanclass="special">:</span><spanclass="keyword">throw</span>
<spanclass="bold"><strong>Effects:</strong></span> Equivalent to <codeclass="computeroutput"><spanclass="keyword">if</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span><spanclass="keyword">return</span><spanclass="special">**</span><spanclass="keyword">this</span><spanclass="special">;</span><spanclass="keyword">else</span><spanclass="keyword">return</span>
<spanclass="bold"><strong>Remarks:</strong></span> If <codeclass="computeroutput"><spanclass="identifier">T</span></code>
is not <ahref="../../../../../utility/CopyConstructible.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">CopyConstructible</span></code></a> or <codeclass="computeroutput"><spanclass="identifier">U</span><spanclass="special">&&</span></code>
is not convertible to <codeclass="computeroutput"><spanclass="identifier">T</span></code>,
<spanclass="bold"><strong>Notes:</strong></span> On compilers that do not support
ref-qualifiers on member functions this overload is replaced with the
<codeclass="computeroutput"><spanclass="keyword">const</span></code>-qualified member function.
On compilers without rvalue reference support the type of <codeclass="computeroutput"><spanclass="identifier">v</span></code> becomes <codeclass="computeroutput"><spanclass="identifier">U</span>
<spanclass="bold"><strong>Effects:</strong></span> Equivalent to <codeclass="computeroutput"><spanclass="keyword">if</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span><spanclass="keyword">return</span><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">move</span><spanclass="special">(**</span><spanclass="keyword">this</span><spanclass="special">);</span><spanclass="keyword">else</span><spanclass="keyword">return</span><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">forward</span><spanclass="special"><</span><spanclass="identifier">U</span><spanclass="special">>(</span><spanclass="identifier">v</span><spanclass="special">);</span></code>.
is <ahref="../../../../../utility/CopyConstructible.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">CopyConstructible</span></code></a> and <codeclass="computeroutput"><spanclass="identifier">F</span></code> models a <ahref="http://www.sgi.com/tech/stl/Generator.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">Generator</span></code></a> whose result type
is convertible to <codeclass="computeroutput"><spanclass="identifier">T</span></code>.
<spanclass="identifier">clog</span><spanclass="special"><<</span><spanclass="string">"no value returned, using default"</span><spanclass="special"><<</span><spanclass="identifier">endl</span><spanclass="special">;</span>
<spanclass="keyword">int</span><spanclass="identifier">i</span><spanclass="special">=</span><spanclass="identifier">o1</span><spanclass="special">.</span><spanclass="identifier">value_or_eval</span><spanclass="special">(</span><spanclass="identifier">complain_and_0</span><spanclass="special">);</span><spanclass="comment">// fun not called</span>
<spanclass="keyword">int</span><spanclass="identifier">j</span><spanclass="special">=</span><spanclass="identifier">oN</span><spanclass="special">.</span><spanclass="identifier">value_or_eval</span><spanclass="special">(</span><spanclass="identifier">complain_and_0</span><spanclass="special">);</span><spanclass="comment">// fun called</span>
is <codeclass="computeroutput"><spanclass="identifier">MoveConstructible</span></code>
and <codeclass="computeroutput"><spanclass="identifier">F</span></code> models a <ahref="http://www.sgi.com/tech/stl/Generator.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">Generator</span></code></a>
whose result type is convertible to <codeclass="computeroutput"><spanclass="identifier">T</span></code>.
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">get_value_or</span><spanclass="special">(</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">get_value_or</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">></span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">o</span><spanclass="special">,</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="keyword">default</span><spanclass="special">)</span><spanclass="special">;</span></code>
<spanclass="bold"><strong>Deprecated:</strong></span> Use <codeclass="computeroutput"><spanclass="identifier">value_or</span><spanclass="special">()</span></code> instead.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Returns:</strong></span> A reference to the contained
value, if any, or <codeclass="computeroutput"><spanclass="keyword">default</span></code>.
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">get_ptr</span><spanclass="special">()</span><spanclass="keyword">const</span><spanclass="special">;</span></code>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="identifier">get_ptr</span><spanclass="special">()</span><spanclass="special">;</span></code>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">></span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span><spanclass="special">;</span></code>
<spanclass="bold"><strong>Returns:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized, a pointer to the
<spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span><spanclass="special">->()</span>
<spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">>::</span><spanclass="keyword">operator</span>
<spanclass="bold"><strong>Requires: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Returns:</strong></span> A pointer to the contained
<spanclass="bold"><strong>Returns:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is uninitialized, <codeclass="computeroutput"><spanclass="keyword">true</span></code>;
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">></span><spanclass="identifier">make_optional</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="identifier">v</span><spanclass="special">)</span></code>
<spanclass="bold"><strong>Returns: </strong></span><codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">>(</span><spanclass="identifier">v</span><spanclass="special">)</span></code> for the <spanclass="emphasis"><em>deduced</em></span>
type <codeclass="computeroutput"><spanclass="identifier">T</span></code> of <codeclass="computeroutput"><spanclass="identifier">v</span></code>.
<spanclass="identifier">foo</span><spanclass="special">(</span><spanclass="identifier">make_optional</span><spanclass="special">(</span><spanclass="number">1</span><spanclass="special">+</span><spanclass="number">1</span><spanclass="special">)</span><spanclass="special">)</span><spanclass="special">;</span><spanclass="comment">// Creates an optional<int></span>
<codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span></code><spanclass="emphasis"><em>(not a ref)</em></span><codeclass="computeroutput"><spanclass="special">></span><spanclass="identifier">make_optional</span><spanclass="special">(</span><spanclass="keyword">bool</span><spanclass="identifier">condition</span><spanclass="special">,</span>
<spanclass="bold"><strong>Returns: </strong></span><codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">>(</span><spanclass="identifier">condition</span><spanclass="special">,</span><spanclass="identifier">v</span><spanclass="special">)</span></code> for the <spanclass="emphasis"><em>deduced</em></span>
type <codeclass="computeroutput"><spanclass="identifier">T</span></code> of <codeclass="computeroutput"><spanclass="identifier">v</span></code>.
shall meet requirements of <ahref="http://www.sgi.com/tech/stl/EqualityComparable.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">EqualityComparable</span></code></a>.
If only <codeclass="computeroutput"><spanclass="identifier">x</span></code> or <codeclass="computeroutput"><spanclass="identifier">y</span></code> is initialized, <codeclass="computeroutput"><spanclass="keyword">false</span></code>.
If both are uninitialized, <codeclass="computeroutput"><spanclass="keyword">true</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> Pointers have shallow relational
operators while <codeclass="computeroutput"><spanclass="identifier">optional</span></code>
has deep relational operators. Do not use <codeclass="computeroutput"><spanclass="keyword">operator</span><spanclass="special">==</span></code> directly in generic code which expect
to be given either an <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">></span></code> or a pointer; use <ahref="../../../../../utility/OptionalPointee.html#equal"target="_top"><codeclass="computeroutput"><spanclass="identifier">equal_pointees</span><spanclass="special">()</span></code></a>
<spanclass="identifier">assert</span><spanclass="special">(</span><spanclass="identifier">oN</span><spanclass="special">==</span><spanclass="identifier">oN_</span><spanclass="special">);</span><spanclass="comment">// Both uninitialized compare equal</span>
<spanclass="identifier">assert</span><spanclass="special">(</span><spanclass="identifier">oN</span><spanclass="special">!=</span><spanclass="identifier">o1</span><spanclass="special">);</span><spanclass="comment">// Initialized unequal to initialized.</span>
<spanclass="identifier">assert</span><spanclass="special">(</span><spanclass="identifier">o1</span><spanclass="special">==</span><spanclass="identifier">o1_</span><spanclass="special">);</span><spanclass="comment">// Both initialized compare as (*lhs == *rhs)</span>
has deep relational operators. Do not use <codeclass="computeroutput"><spanclass="keyword">operator</span><spanclass="special"><</span></code> directly in generic code which expect
to be given either an <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">></span></code> or a pointer; use <ahref="../../../../../utility/OptionalPointee.html#less"target="_top"><codeclass="computeroutput"><spanclass="identifier">less_pointees</span><spanclass="special">()</span></code></a>
instead. <codeclass="computeroutput"><spanclass="identifier">T</span></code> need not be
<ahref="http://www.sgi.com/tech/stl/LessThanComparable.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">LessThanComparable</span></code></a>. Only single
is required. Other relational operations are defined in terms of this
one. If <codeclass="computeroutput"><spanclass="identifier">T</span></code>'s <codeclass="computeroutput"><spanclass="keyword">operator</span><spanclass="special"><</span></code>
satisfies the axioms of <ahref="http://www.sgi.com/tech/stl/LessThanComparable.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">LessThanComparable</span></code></a> (transitivity,
antisymmetry and irreflexivity), <codeclass="computeroutput"><spanclass="identifier">optinal</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">></span></code> is <ahref="http://www.sgi.com/tech/stl/LessThanComparable.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">LessThanComparable</span></code></a>.
<spanclass="identifier">assert</span><spanclass="special">(</span><spanclass="special">!(</span><spanclass="identifier">oN</span><spanclass="special"><</span><spanclass="identifier">oN_</span><spanclass="special">)</span><spanclass="special">);</span><spanclass="comment">// Two uninitialized are equivalent</span>
<spanclass="identifier">assert</span><spanclass="special">(</span><spanclass="identifier">oN</span><spanclass="special"><</span><spanclass="identifier">o0</span><spanclass="special">);</span><spanclass="comment">// Uninitialized is less than initialized</span>
<spanclass="identifier">assert</span><spanclass="special">(</span><spanclass="identifier">o1</span><spanclass="special"><</span><spanclass="identifier">o2</span><spanclass="special">)</span><spanclass="special">;</span><spanclass="comment">// Two initialized compare as (*lhs < *rhs)</span>
need not meet requirements of <ahref="http://www.sgi.com/tech/stl/EqualityComparable.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">EqualityComparable</span></code></a>.
<spanclass="bold"><strong>Requires:</strong></span> Lvalues of type <codeclass="computeroutput"><spanclass="identifier">T</span></code> shall be swappable and <codeclass="computeroutput"><spanclass="identifier">T</span></code> shall be <codeclass="computeroutput"><spanclass="identifier">MoveConstructible</span></code>.
If <codeclass="computeroutput"><spanclass="special">!*</span><spanclass="keyword">this</span>
<spanclass="special">&&</span><spanclass="special">!</span><spanclass="identifier">rhs</span></code>, no effect, otherwise
</li>
<liclass="listitem">
if <codeclass="computeroutput"><spanclass="keyword">bool</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span>
<spanclass="special">&&</span><spanclass="special">!</span><spanclass="identifier">rhs</span></code>, initializes the contained
value of <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> as
if direct-initializing an object of type <codeclass="computeroutput"><spanclass="identifier">T</span></code>
with the expression <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">move</span><spanclass="special">(*(*</span><spanclass="keyword">this</span><spanclass="special">))</span></code>, followed by <codeclass="computeroutput"><spanclass="identifier">val</span><spanclass="special">-></span><spanclass="identifier">T</span><spanclass="special">::~</span><spanclass="identifier">T</span><spanclass="special">()</span></code>, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> does not contain a value and
<codeclass="computeroutput"><spanclass="identifier">rhs</span></code> contains a
value, otherwise
</li>
<liclass="listitem">
if <codeclass="computeroutput"><spanclass="special">!*</span><spanclass="keyword">this</span>
<spanclass="special">&&</span><spanclass="keyword">bool</span><spanclass="special">(</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code>, initializes the contained value
of <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
as if direct-initializing an object of type <codeclass="computeroutput"><spanclass="identifier">T</span></code>
with the expression <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">move</span><spanclass="special">(*</span><spanclass="identifier">rhs</span><spanclass="special">)</span></code>, followed by <codeclass="computeroutput"><spanclass="identifier">rhs</span><spanclass="special">.</span><spanclass="identifier">val</span><spanclass="special">-></span><spanclass="identifier">T</span><spanclass="special">::~</span><spanclass="identifier">T</span><spanclass="special">()</span></code>, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> contains a value and <codeclass="computeroutput"><spanclass="identifier">rhs</span></code> does not contain a value,
<spanclass="bold"><strong>Postconditions:</strong></span> The states of <codeclass="computeroutput"><spanclass="identifier">x</span></code> and <codeclass="computeroutput"><spanclass="identifier">y</span></code>
interchanged.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> If both are initialized, whatever
throws. If only one is initialized, whatever <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&&</span><spanclass="special">)</span></code>
<spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">swap</span><spanclass="special">(</span><spanclass="identifier">def0</span><spanclass="special">,</span><spanclass="identifier">optX</span><spanclass="special">);</span><spanclass="comment">// Get back to original values</span>
<tdalign="right"><divclass="copyright-footer">Copyright © 2003-2007 Fernando Luis Cacciola Carballal<br>Copyright © 2014, 2015 Andrzej Krzemieński<p>
