<aname="boost_optional.a_note_about_optional_bool_"></a><aclass="link"href="a_note_about_optional_bool_.html"title="A note about optional<bool>">A note about
<aname="boost_optional.dependencies_and_portability"></a><aclass="link"href="dependencies_and_portability.html"title="Dependencies and Portability">Dependencies
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>
<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>
<li>
<liclass="listitem">
If the entry reads: <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">></span></code>,
<spanclass="bold"><strong>Effect:</strong></span> Default-Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<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>
<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> that can be used as the parameter.
<spanclass="bold"><strong>Effect:</strong></span> Directly-Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<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="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code> is
called.
</li>
<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="bold"><strong>Effect:</strong></span> Directly-Constructs an <codeclass="computeroutput"><spanclass="identifier">optional</span></code>.
</li>
<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
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> is uninitialized.
<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>
<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="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>
<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="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>
<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>
<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>
<li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> See <aclass="link"href="in_place_factories.html"title="In-Place Factories">In-Place
Factories</a>
</li>
<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 effect.
<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>
<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>
<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
<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>
<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
@ -565,7 +565,7 @@
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>
<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>
<li>
<liclass="listitem">
<spanclass="bold"><strong>Notes:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> was initialized, is is <spanclass="emphasis"><em>rebound</em></span>
to the new object. See <aclass="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">here</a>
<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>
<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> is uninitialized.
</li>
<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></code> or <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::</span><spanclass="identifier">T</span><spanclass="special">(</span>
<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>
<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
@ -676,7 +676,7 @@
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>
<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>
<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 *rhs, this
is is <spanclass="emphasis"><em>rebound</em></span> to the new object. See <aclass="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">here</a>
<spanclass="bold"><strong>Effect:</strong></span> Assigns another convertible optional
to an optional.
</li>
<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>
<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
<spanclass="bold"><strong>Notes:</strong></span> If both <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> and rhs 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></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,
<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
@ -787,7 +787,7 @@
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="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">detail</span><spanclass="special">::</span><spanclass="identifier">none_t</span><spanclass="special">);</span></code>
<spanclass="bold"><strong>Requirements:</strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized
</li>
<li>
<liclass="listitem">
<spanclass="bold"><strong>Returns:</strong></span> A reference to the contained value
<spanclass="bold"><strong>Requirements: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized
<spanclass="bold"><strong>Returns:</strong></span> If <codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized, a pointer to the contained
<spanclass="bold"><strong>Requirements: </strong></span><codeclass="computeroutput"><spanclass="special">*</span><spanclass="keyword">this</span></code> is initialized.
</li>
<li>
<liclass="listitem">
<spanclass="bold"><strong>Returns:</strong></span> A pointer to the contained value.
<spanclass="bold"><strong>Returns:</strong></span> An unspecified value which if used
on a boolean context is equivalent to (<codeclass="computeroutput"><spanclass="identifier">get</span><spanclass="special">()</span><spanclass="special">!=</span><spanclass="number">0</span></code>)
<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>;
<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>
<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>.
<spanclass="bold"><strong>Returns:</strong></span> 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="special">==</span>
<spanclass="special">*</span><spanclass="identifier">y</span><spanclass="special">)</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>
@ -1417,7 +1417,7 @@
or a pointer; use <ahref="../../../../utility/OptionalPointee.html#equal"target="_top"><codeclass="computeroutput"><spanclass="identifier">equal_pointees</span><spanclass="special">()</span></code></a>
<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="special"><</span><spanclass="special">*</span><spanclass="identifier">y</span><spanclass="special">)</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>
@ -1478,7 +1478,7 @@
or a pointer; use <ahref="../../../../utility/OptionalPointee.html#less"target="_top"><codeclass="computeroutput"><spanclass="identifier">less_pointees</span><spanclass="special">()</span></code></a>
<spanclass="bold"><strong>Effect:</strong></span> If both <codeclass="computeroutput"><spanclass="identifier">x</span></code>
and <codeclass="computeroutput"><spanclass="identifier">y</span></code> are initialized, calls
<codeclass="computeroutput"><spanclass="identifier">swap</span><spanclass="special">(*</span><spanclass="identifier">x</span><spanclass="special">,*</span><spanclass="identifier">y</span><spanclass="special">)</span></code> using <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">swap</span></code>.
If only one is initialized, say <codeclass="computeroutput"><spanclass="identifier">x</span></code>,
calls: <codeclass="computeroutput"><spanclass="identifier">y</span><spanclass="special">.</span><spanclass="identifier">reset</span><spanclass="special">(*</span><spanclass="identifier">x</span><spanclass="special">);</span><spanclass="identifier">x</span><spanclass="special">.</span><spanclass="identifier">reset</span><spanclass="special">();</span></code> If none is initialized, does nothing.
</li>
<li>
<liclass="listitem">
<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>
<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="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="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="identifier">reset</span><spanclass="special">(</span><spanclass="identifier">T</span><spanclass="keyword">const</span><spanclass="special">&</span><spanclass="special">)</span></code>.
between containers compare container size and if match, contained value
</li>
<li>
<liclass="listitem">
If the container is not empty (contains an object of type <codeclass="computeroutput"><spanclass="identifier">T</span></code>), it is modeling an <spanclass="emphasis"><em>initialized</em></span>
optional.
</li>
<li>
<liclass="listitem">
If the container is empty, it is modeling an <spanclass="emphasis"><em>uninitialized</em></span>
optional.
</li>
<li>
<liclass="listitem">
Testing if the container is empty models testing if the optional is initialized
</li>
<li>
<liclass="listitem">
Trying to extract a <codeclass="computeroutput"><spanclass="identifier">T</span></code> from
an empty container models the undefined behavior of trying to access the
We can draw from the purpose of <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">></span></code>
<divclass="section"title="Optional local variables">
<divclass="titlepage"><div><div><h3class="title">
<aname="boost_optional.examples.optional_local_variables"></a><aclass="link"href="examples.html#boost_optional.examples.optional_local_variables"title="Optional local variables">Optional
local variables</a>
@ -78,7 +78,7 @@
<spanclass="keyword">else</span><spanclass="identifier">print</span><spanclass="special">(</span><spanclass="string">"employer's name not found!"</span><spanclass="special">);</span>
</pre>
</div>
<divclass="section"lang="en">
<divclass="section"title="Optional data members">
<divclass="titlepage"><div><div><h3class="title">
<aname="boost_optional.examples.optional_data_members"></a><aclass="link"href="examples.html#boost_optional.examples.optional_data_members"title="Optional data members">Optional
Provide the no-throw guarantee (assuming a no-throw <codeclass="computeroutput"><spanclass="identifier">T</span><spanclass="special">::~</span><spanclass="identifier">T</span><spanclass="special">()</span></code>)
<spanclass="underline">TypedInPlaceFactories</span>: those which
take the target type as a primary template parameter.
</li>
<li>
<liclass="listitem">
<spanclass="underline">InPlaceFactories</span>: those with a template
<codeclass="computeroutput"><spanclass="identifier">construct</span><spanclass="special">(</span><spanclass="keyword">void</span><spanclass="special">*)</span></code> member
Copies of <codeclass="computeroutput"><spanclass="identifier">optional</span><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">&></span></code>
will copy the references but all these references will nonetheless reefer
to the same object.
</li>
<li>
<liclass="listitem">
Value-access will actually provide access to the referenced object rather
<aname="boost_optional.rebinding_semantics_for_assignment_of_optional_references"></a><aclass="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">Rebinding
semantics for assignment of optional references</a>
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Daniel James