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>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="special">)</span></code> is called. The expression inside
<codeclass="computeroutput"><spanclass="keyword">noexcept</span></code> is equivalent to
<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>
<spanclass="bold"><strong>Effect:</strong></span> Move-constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</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 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>
<spanclass="bold"><strong>Effect:</strong></span> Assigns another <codeclass="computeroutput"><spanclass="identifier">optional</span></code> to an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</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>; else <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</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><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> 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 [destructor] 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>copy constructor</em></span> 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
<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 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>
<spanclass="bold"><strong>Effect:</strong></span> Move-assigns another <codeclass="computeroutput"><spanclass="identifier">optional</span></code> to an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</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 <codeclass="computeroutput"><spanclass="special">*</span><spanclass="identifier">rhs</span></code>, <codeclass="computeroutput"><spanclass="identifier">rhs</span></code>
remains initialized; 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">T</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>move assignment operator</em></span> 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
[destructor] 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>move constructor</em></span> is called. The expression inside
<codeclass="computeroutput"><spanclass="keyword">noexcept</span></code> is equivalent to
<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
<spanclass="emphasis"><em>move constructor</em></span> fails, <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is left properly uninitialized.
<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.
<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="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
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>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>Returns:</strong></span> A reference to the contained
value, if <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is initialized.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> An instance of <codeclass="computeroutput"><spanclass="identifier">bad_optional_access</span></code>, if <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code>
is not initialized.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> 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> member functions.
<spanclass="bold"><strong>Returns:</strong></span> First overload: <codeclass="computeroutput"><spanclass="keyword">bool</span><spanclass="special">(*</span><spanclass="keyword">this</span><spanclass="special">)</span><spanclass="special">?</span><spanclass="special">**</span><spanclass="keyword">this</span>
<spanclass="special">:</span><spanclass="keyword">static_cast</span><spanclass="special"><</span><spanclass="identifier">T</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>. second overload: <codeclass="computeroutput"><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="keyword">this</span><spanclass="special">)</span><spanclass="special">:</span><spanclass="keyword">static_cast</span><spanclass="special"><</span><spanclass="identifier">T</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>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Throws:</strong></span> Any exception thrown by the
selected constructor of <codeclass="computeroutput"><spanclass="identifier">T</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> 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> member functions.
On compilers without rvalue reference support the type of <codeclass="computeroutput"><spanclass="identifier">v</span></code> becomes <codeclass="computeroutput"><spanclass="identifier">U</span>
<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>.
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>.
<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>
shall meet requirements of <codeclass="computeroutput"><spanclass="identifier">LessThanComparable</span></code>.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Returns:</strong></span> If <codeclass="computeroutput"><spanclass="identifier">y</span></code>
is not initialized, <codeclass="computeroutput"><spanclass="keyword">false</span></code>.
If <codeclass="computeroutput"><spanclass="identifier">y</span></code> is initialized and
<codeclass="computeroutput"><spanclass="identifier">x</span></code> is not initialized,
<codeclass="computeroutput"><spanclass="keyword">true</span></code>. If both <codeclass="computeroutput"><spanclass="identifier">x</span></code> and <codeclass="computeroutput"><spanclass="identifier">y</span></code>
are initialized, <codeclass="computeroutput"><spanclass="special">(*</span><spanclass="identifier">x</span>
<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#less"target="_top"><codeclass="computeroutput"><spanclass="identifier">less_pointees</span><spanclass="special">()</span></code></a>
using <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">swap</span></code>. If only one is initialized, say
<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>
throws.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If both are initialized, <codeclass="computeroutput"><spanclass="identifier">swap</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&,</span><spanclass="identifier">T</span><spanclass="special">&)</span></code>
is used unqualified but with <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">swap</span></code>
introduced in scope. If only one is initialized, <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::~</span><spanclass="identifier">T</span><spanclass="special">()</span></code> and <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>
is called.
</li>
<liclass="listitem">
<spanclass="bold"><strong>Exception Safety:</strong></span> If both are initialized,
this operation has the exception safety guarantees of <codeclass="computeroutput"><spanclass="identifier">swap</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="special">&,</span><spanclass="identifier">T</span><spanclass="special">&)</span></code>. If only one is initialized, it
has the same basic guarantee 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">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 Andrzej Krzemieński<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <ahref="http://www.boost.org/LICENSE_1_0.txt"target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
