and checking if the old value pointer is not null before dereferencing it
in postconditions. For example, consider the following function template
that could in general be instantiated for types <code class="computeroutput"><span class="identifier">T</span></code>
- that are not copy constructible (that is for which <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">is_old_value_copyable</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>,
+ that are not copy constructible (that is for which <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>,
see <a href="../../../example/features/old_if_copyable.cpp" target="_top"><code class="literal">old_if_copyable.cpp</code></a>):
<a href="#ftn.boost_contract.extras.old_value_requirements__templates_.f0" class="footnote" name="boost_contract.extras.old_value_requirements__templates_.f0"><sup class="footnote">[68]</sup></a>
</p>
<p>
The old value pointer <code class="computeroutput"><span class="identifier">old_x</span></code>
is programmed using <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>.
- When <code class="computeroutput"><span class="identifier">T</span></code> is copyable, this
- <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">old_ptr_if_copyable</span><span class="special">]<</span><span class="identifier">T</span><span class="special">></span></code> behaves
- like <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">old_ptr</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>.
+ When <code class="computeroutput"><span class="identifier">T</span></code> is copyable, <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>
+ behaves like <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr.html" title="Class template old_ptr">boost::contract::old_ptr</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>.
When <code class="computeroutput"><span class="identifier">T</span></code> is not copyable instead,
- <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">old_ptr_if_copyable</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code> will
- simply not copy <code class="computeroutput"><span class="identifier">x</span></code> at run-time
- and leave <code class="computeroutput"><span class="identifier">old_x</span></code> initialized
-
as a null pointer. Therefore, <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>
+ <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>
+ will simply not copy <code class="computeroutput"><span class="identifier">x</span></code> at
+ run-time and leave <code class="computeroutput"><span class="identifier">old_x</span></code>
+
initialized to a null pointer. Therefore, <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>
objects like <code class="computeroutput"><span class="identifier">old_x</span></code> must be
checked to be not null as in <code class="computeroutput"><span class="keyword">if</span><span class="special">(</span><span class="identifier">old_x</span><span class="special">)</span> <span class="special">...</span></code> before
- they are dereferenced in postconditions and exception guarantees.
+ they are dereferenced in postconditions and exception guarantees (to avoid
+ run-time errors of dereferencing null pointers).
</p>
<p>
If the above example used <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr.html" title="Class template old_ptr">boost::contract::old_ptr</a></code>
<code class="computeroutput"><span class="identifier">offset</span></code> is instantiated with
types <code class="computeroutput"><span class="identifier">T</span></code> that are not copy
constructible (but only if <code class="computeroutput"><span class="identifier">old_x</span></code>
- is actually dereferenced somewhere in the contract assertions using <code class="computeroutput"><span class="special">*</span><span class="identifier">old_x</span> <span class="special">...</span></code>, <code class="computeroutput"><span class="identifier">old_x</span><span class="special">->...</span></code>, etc.).
+ is actually dereferenced somewhere, for example in the contract assertions
+ using <code class="computeroutput"><span class="special">*</span><span class="identifier">old_x</span>
+ <span class="special">...</span></code> or <code class="computeroutput"><span class="identifier">old_x</span><span class="special">->...</span></code>). <a href="#ftn.boost_contract.extras.old_value_requirements__templates_.f1" class="footnote" name="boost_contract.extras.old_value_requirements__templates_.f1"><sup class="footnote">[69]</sup></a>
</p>
<p>
When C++11 <code class="computeroutput"><span class="keyword">auto</span></code> declarations
are used with <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OLDOF.html" title="Macro BOOST_CONTRACT_OLDOF">BOOST_CONTRACT_OLDOF</a></code>,
this library always defaults to using the <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr.html" title="Class template old_ptr">boost::contract::old_ptr</a></code>
type (because its type requirements are more stringent than <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>).
- If programmers want to relax the copyable type requirement, they must do
- so explicitly by using <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>
- instead of using <code class="computeroutput"><span class="keyword">auto</span></code>. For example,
- the following statements are equivalent:
+ For example, the following statements are equivalent:
</p>
<pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">old_x</span> <span class="special">=</span> <span class="identifier">BOOST_CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="comment">// C++11 auto declarations always use `old_ptr` (never `old_ptr_if_copyable`).</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">old_ptr</span><span class="special"><</span><span class="keyword">decltype</span><span class="special">(</span><span class="identifier">x</span><span class="special">)></span> <span class="identifier">old_x</span> <span class="special">=</span> <span class="identifier">BOOST_CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
</pre>
<p>
+ If programmers want to relax the copyable type requirement, they must do
+ so explicitly by using the <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>
+ type instead of using <code class="computeroutput"><span class="keyword">auto</span></code> declarations.
+ </p>
+<h5>
+<a name="boost_contract.extras.old_value_requirements__templates_.h0"></a>
+ <span class="phrase"><a name="boost_contract.extras.old_value_requirements__templates_.old_value_type_traits"></a></span><a class="link" href="extras.html#boost_contract.extras.old_value_requirements__templates_.old_value_type_traits">Old
+ Value Type Traits</a>
+ </h5>
+<p>
This library uses <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code>
to determine if an old value type is copyable or not, and then <code class="computeroutput"><a class="link" href="../boost/contract/old_value_copy.html" title="Struct template old_value_copy">boost::contract::old_value_copy</a></code>
- to actually copy the old value. By default, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">is_old_value_copyable</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>
+ to actually copy the old value.
+ </p>
+<p>
+ By default, <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>
is equivalent to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_copy_constructible</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code> and
- <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">old_value_copy</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code> is
- implemented using <code class="computeroutput"><span class="identifier">T</span></code>'s copy
- constructor. However, these type traits can be specialized by programmers
+ <code class="computeroutput"><a class="link" href="../boost/contract/old_value_copy.html" title="Struct template old_value_copy">boost::contract::old_value_copy</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>
+ is implemented using <code class="computeroutput"><span class="identifier">T</span></code>'s
+ copy constructor. However, these type traits can be specialized by programmers
for example to avoid making old value copies of types even when they have
a copy constructor (maybe because these copy constructors are too expensive),
or to make old value copies for types that do not have a copy constructor,
or for any other specific need programmers might have for the types in question.
+ </p>
+<p>
For example, the following specialization of <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code>
intentionally avoids making old value copies for all expressions of type
<code class="computeroutput"><span class="identifier">w</span></code> even if that type has a
<pre class="programlisting"><span class="comment">// Copyable type but...</span>
<span class="keyword">class</span> <span class="identifier">w</span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
- <span class="identifier">w</span><span class="special">(</span><span class="identifier">w</span> <span class="keyword">const</span><span class="special">&)</span> <span class="special">{</span> <span class="comment">/* Some very expensive copy here operation here... */</span> <span class="special">}</span>
+ <span class="identifier">w</span><span class="special">(</span><span class="identifier">w</span> <span class="keyword">const</span><span class="special">&)</span> <span class="special">{</span> <span class="comment">/* Some very expensive copy operation here... */</span> <span class="special">}</span>
<span class="comment">/* ... */</span>
</pre>
</pre>
<p>
</p>
-<h5>
-<a name="boost_contract.extras.old_value_requirements__templates_.h0"></a>
- <span class="phrase"><a name="boost_contract.extras.old_value_requirements__templates_.no_c__11"></a></span><a class="link" href="extras.html#boost_contract.extras.old_value_requirements__templates_.no_c__11">No
- C++11</a>
- </h5>
<p>
In general, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_copy_constructible</span></code> and therefore <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code>
require C++11 <code class="computeroutput"><span class="keyword">decltype</span></code> and SFINAE
- to automatically detect if a given type is not copyable. On non-C++11 compilers,
- it is possible to inherit the old value type from <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span></code>,
- or use <code class="computeroutput"><span class="identifier">BOOST_MOVABLE_BUT_NOT_COPYABLE</span></code>,
+ to automatically detect if a given type is copyable or not. On non-C++11
+ compilers, it is possible to inherit the old value type from <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span></code>, or use <code class="computeroutput"><span class="identifier">BOOST_MOVABLE_BUT_NOT_COPYABLE</span></code>,
or specialize <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_copy_constructible</span></code> (see <a href="http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/boost_typetraits/reference/is_copy_constructible.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_copy_constructible</span></code></a> documentation
- for more information). Alternatively, it is possible to just specialize
- <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code>.
+ for more information), or just specialize <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code>.
For example, for a non-copyable type <code class="computeroutput"><span class="identifier">n</span></code>
- (see <a href="../../../example/features/old_if_copyable.cpp" target="_top"><code class="literal">old_if_copyable.cpp</code></a>):
+
the following code will work also on non-C++11 compilers (see <a href="../../../example/features/old_if_copyable.cpp" target="_top"><code class="literal">old_if_copyable.cpp</code></a>):
</p>
<p>
</p>
</p>
<p>
However, in some other cases it might be desirable to not augment the type
- requirements of a program because of contract assertions and to simply skip
- these assertions when user types do not provide all the operations necessary
+ requirements of a program just because of contract assertions and to simply
+ skip assertions when user types do not provide all the operations necessary
to check them, without causing compile-time errors. Programmers can do this
- using <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
- (or <code class="computeroutput"><a class="link" href="../boost/contract/condition_if_c.html" title="Function template condition_if_c">boost::contract::condition_if_c</a></code>).
+ using <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
+ on C++17 compilers, and <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
+ (or <code class="computeroutput"><a class="link" href="../boost/contract/condition_if_c.html" title="Function template condition_if_c">boost::contract::condition_if_c</a></code>)
+ on non-C++17 compilers.
</p>
<p>
For example, let's consider the following <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>
users instantiate <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span></code>
with a type <code class="computeroutput"><span class="identifier">T</span></code> that does not
provide an equality operator <code class="computeroutput"><span class="special">==</span></code>.
- Otherwise, programmers can specify this postcondition using <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
+ Otherwise, programmers can guard this postcondition using C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
to evaluate the asserted condition only for types <code class="computeroutput"><span class="identifier">T</span></code>
that have an equality operator <code class="computeroutput"><span class="special">==</span></code>
- (and trivially evaluate to <code class="computeroutput"><span class="keyword">true</span></code>
- otherwise). On C++17 compilers, the same can be achieved using <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
- instead of <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
- resulting in a more concise and readable syntax. <a href="#ftn.boost_contract.extras.assertion_requirements__templates_.f0" class="footnote" name="boost_contract.extras.assertion_requirements__templates_.f0"><sup class="footnote">[69]</sup></a> For example (see <a href="../../../example/features/condition_if.cpp" target="_top"><code class="literal">condition_if.cpp</code></a>):
+ and skip it otherwise. <a href="#ftn.boost_contract.extras.assertion_requirements__templates_.f0" class="footnote" name="boost_contract.extras.assertion_requirements__templates_.f0"><sup class="footnote">[70]</sup></a> For example:
</p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- Until C++17 (without <code class="computeroutput"><span class="keyword">if</span>
- <span class="keyword">constexpr</span></code>)
- </p>
- </th>
-<th>
- <p>
- Since C++17 (with <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>)
- </p>
- </th>
-</tr></thead>
-<tbody><tr>
-<td>
- <p>
-</p>
-<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
+<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">vector</span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">void</span> <span class="identifier">push_back</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&</span> <span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">public_function</span><span class="special">(</span><span class="keyword">this</span><span class="special">)</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boot</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">public_function</span><span class="special">(</span><span class="keyword">this</span><span class="special">)</span>
<span class="special">.</span><span class="identifier">postcondition</span><span class="special">([&]</span> <span class="special">{</span>
- <span class="comment">// Instead of `ASSERT(back() == value)` for T without `==`.</span>
- <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">condition_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">>(</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(),</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">cref</span><span class="special">(</span><span class="identifier">back</span><span class="special">()),</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">cref</span><span class="special">(</span><span class="identifier">value</span><span class="special">)</span>
- <span class="special">)</span>
- <span class="special">)</span>
- <span class="special">);</span>
+ <span class="comment">// Guard with `if constexpr` for T without `==`.</span>
+ <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span>
+ <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">})</span>
<span class="special">;</span>
<span class="comment">/* ... */</span>
</pre>
<p>
- </p>
- </td>
-<td>
- <p>
+ More in general, <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
+ can be used to guard a mix of both old value copies and contract assertions
+ that introduce specific extra type requirements. For example, the following
+ <code class="computeroutput"><span class="identifier">swap</span></code> function can be called
+ on any type <code class="computeroutput"><span class="identifier">T</span></code> that is movable
+ but its old value copies and postcondition assertions are evaluated only
+ for types <code class="computeroutput"><span class="identifier">T</span></code> that are also
+ copyable and have an equality operator <code class="computeroutput"><span class="special">==</span></code>
+ (see <a href="../../../example/features/if_constexpr.cpp" target="_top"><code class="literal">if_constexpr.cpp</code></a>):
+ </p>
+<p>
</p>
-<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
+<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
+<span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">T</span><span class="special">&</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">is_old_value_copyable</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span> <span class="special">&&</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span><span class="special">;</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">old_ptr</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="identifier">old_x</span><span class="special">,</span> <span class="identifier">old_y</span><span class="special">;</span>
+ <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">{</span> <span class="comment">// Contract requires copyable T...</span>
+ <span class="identifier">old_x</span> <span class="special">=</span> <span class="identifier">BOOST_CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
+ <span class="identifier">old_y</span> <span class="special">=</span> <span class="identifier">BOOST_CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span>
+ <span class="special">}</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">function</span><span class="special">()</span>
+ <span class="special">.</span><span class="identifier">postcondition</span><span class="special">([&]</span> <span class="special">{</span>
+ <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">{</span> <span class="comment">// ... and T with `==`...</span>
+ <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">x</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">old_y</span><span class="special">);</span>
+ <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">old_x</span><span class="special">);</span>
+ <span class="special">}</span>
+ <span class="special">})</span>
+ <span class="special">;</span>
+
+ <span class="identifier">T</span> <span class="identifier">t</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="comment">// ...but body only requires movable T.</span>
+ <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span>
+ <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">move</span><span class="special">(</span><span class="identifier">t</span><span class="special">);</span>
+<span class="special">}</span>
+</pre>
+<p>
+ </p>
+<h5>
+<a name="boost_contract.extras.assertion_requirements__templates_.h0"></a>
+ <span class="phrase"><a name="boost_contract.extras.assertion_requirements__templates_.no__code__phrase_role__keyword__if__phrase___phrase_role__keyword__constexpr__phrase___code___no_c__17_"></a></span><a class="link" href="extras.html#boost_contract.extras.assertion_requirements__templates_.no__code__phrase_role__keyword__if__phrase___phrase_role__keyword__constexpr__phrase___code___no_c__17_">No
+ <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
+ (no C++17)</a>
+ </h5>
+<p>
+ On non-C++17 compilers where <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code> is not available, it is possible
+ to use <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
+ to skip assertions based on type requirements (even if this code is less
+ readable and more verbose than using <code class="computeroutput"><span class="keyword">if</span>
+ <span class="keyword">constexpr</span></code>). For example (see <a href="../../../example/features/condition_if.cpp" target="_top"><code class="literal">condition_if.cpp</code></a>):
+ </p>
+<p>
+</p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">vector</span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">void</span> <span class="identifier">push_back</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&</span> <span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boot</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">public_function</span><span class="special">(</span><span class="keyword">this</span><span class="special">)</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">public_function</span><span class="special">(</span><span class="keyword">this</span><span class="special">)</span>
<span class="special">.</span><span class="identifier">postcondition</span><span class="special">([&]</span> <span class="special">{</span>
- <span class="comment">// Guard with `if constexpr` for T without `==`.</span>
- <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span>
- <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span><span class="special">);</span>
+ <span class="comment">// Instead of `ASSERT(back() == value)` for T without `==`.</span>
+ <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">condition_if</span><span class="special"><</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="special">>(</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(),</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">cref</span><span class="special">(</span><span class="identifier">back</span><span class="special">()),</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">cref</span><span class="special">(</span><span class="identifier">value</span><span class="special">)</span>
+ <span class="special">)</span>
+ <span class="special">)</span>
+ <span class="special">);</span>
<span class="special">})</span>
<span class="special">;</span>
<span class="identifier">vect_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
-
-
-
-
-
-
<span class="comment">/* ... */</span>
</pre>
<p>
- </p>
- </td>
-</tr></tbody>
-</table></div>
+ </p>
<p>
More in general, <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
is used as follow:
a nullary boolean functor. If <code class="computeroutput"><span class="identifier">Pred</span><span class="special">::</span><span class="identifier">value</span></code>
is statically evaluated to be <code class="computeroutput"><span class="keyword">true</span></code>
at compile-time then <code class="computeroutput"><span class="identifier">cond</span><span class="special">()</span></code> is called at run-time and its boolean result
- is returned by the enclosing <code class="computeroutput">boost::contract::condition_if</code>
+ is returned by the enclosing <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
call. Otherwise, if <code class="computeroutput"><span class="identifier">Pred</span><span class="special">::</span><span class="identifier">value</span></code>
is statically evaluated to be <code class="computeroutput"><span class="keyword">false</span></code>
- at compile-time then <code class="computeroutput">boost::condition_if</code>
+ at compile-time then <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
trivially returns <code class="computeroutput"><span class="keyword">true</span></code>. Therefore,
if <code class="computeroutput"><span class="identifier">cond</span></code> is a functor template
instantiation (not just a functor) then its call that contains the assertion
operations with the extra type requirements (e.g., the equality operator
<code class="computeroutput"><span class="special">==</span></code>) will not be actually instantiated
and compiled unless the compiler determines at compile-time that <code class="computeroutput"><span class="identifier">Pred</span><span class="special">::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
- (functor templates like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span></code>
+ (when used this way, functor templates like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span></code>
and C++14 generic lambdas can be used to program <code class="computeroutput"><span class="identifier">cond</span></code>,
but C++11 lambdas cannot).
</p>
<p>
The <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
function template is a special case of the more general <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>,
- specifically <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">condition_if</span><span class="special"><</span><span class="identifier">Pred</span><span class="special">>(</span><span class="identifier">cond</span><span class="special">)</span></code> is
- equivalent to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">call_if</span><span class="special"><</span><span class="identifier">Pred</span><span class="special">>(</span><span class="identifier">cond</span><span class="special">).</span><span class="identifier">else_</span><span class="special">([]</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span> <span class="special">})</span></code>.
- <a href="#ftn.boost_contract.extras.assertion_requirements__templates_.f1" class="footnote" name="boost_contract.extras.assertion_requirements__templates_.f1"><sup class="footnote">[70]</sup></a> The <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
- function template accepts a number of optional <span class="emphasis"><em>else-if</em></span>
+ specifically <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">Pred</span><span class="special">>(</span><span class="identifier">cond</span><span class="special">)</span></code> is logically equivalent to <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code><code class="computeroutput"><span class="special"><</span><span class="identifier">Pred</span><span class="special">>(</span><span class="identifier">cond</span><span class="special">).</span><span class="identifier">else_</span><span class="special">([]</span> <span class="special">{</span> <span class="keyword">return</span>
+ <span class="keyword">true</span><span class="special">;</span> <span class="special">})</span></code>. <a href="#ftn.boost_contract.extras.assertion_requirements__templates_.f1" class="footnote" name="boost_contract.extras.assertion_requirements__templates_.f1"><sup class="footnote">[71]</sup></a> The <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
+ function template also accepts a number of optional <span class="emphasis"><em>else-if</em></span>
statements and one optional <span class="emphasis"><em>else</em></span> statement:
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">call_if</span><span class="special"><</span><span class="identifier">Pred1</span><span class="special">>(</span>
Where <code class="computeroutput"><span class="identifier">Pred1</span></code>, <code class="computeroutput"><span class="identifier">Pred2</span></code>, ... are nullary boolean meta-functions
and <code class="computeroutput"><span class="identifier">t1</span></code>, <code class="computeroutput"><span class="identifier">t2</span></code>,
..., <code class="computeroutput"><span class="identifier">e</span></code> are nullary functors.
- The return types of the functor calls <code class="computeroutput"><span class="identifier">t1</span><span class="special">()</span></code>, <code class="computeroutput"><span class="identifier">t2</span><span class="special">()</span></code>, ..., <code class="computeroutput"><span class="identifier">e</span><span class="special">()</span></code> must either be all the same (possibly all
- <code class="computeroutput"><span class="keyword">void</span></code>) or be of types implicitly
- convertible into one another. At run-time <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
- will call the functor <code class="computeroutput"><span class="identifier">t1</span><span class="special">()</span></code>, or <code class="computeroutput"><span class="identifier">t2</span><span class="special">()</span></code>, ..., or <code class="computeroutput"><span class="identifier">e</span><span class="special">()</span></code> depending on which meta-function <code class="computeroutput"><span class="identifier">Pred1</span><span class="special">::</span><span class="identifier">value</span></code>, <code class="computeroutput"><span class="identifier">Pred2</span><span class="special">::</span><span class="identifier">value</span></code>,
- ... is statically evaluated to be <code class="computeroutput"><span class="keyword">true</span></code>
- or <code class="computeroutput"><span class="keyword">false</span></code> at compile-time, and
- it will return the value returned by the functor being called. If <code class="computeroutput"><span class="identifier">t1</span></code>, <code class="computeroutput"><span class="identifier">t2</span></code>,
- ..., <code class="computeroutput"><span class="identifier">e</span></code> are nullary functor
- template instantiations (not just nullary functors) then their code will
+ The return types of the functor calls <code class="computeroutput"><span class="identifier">t1</span><span class="special">()</span></code>, <code class="computeroutput"><span class="identifier">t2</span><span class="special">()</span></code>, ..., <code class="computeroutput"><span class="identifier">e</span><span class="special">()</span></code> must either be all the same (including
+ possibly all <code class="computeroutput"><span class="keyword">void</span></code>) or be of
+ types implicitly convertible into one another. At run-time <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code> will
+ call the functor <code class="computeroutput"><span class="identifier">t1</span><span class="special">()</span></code>,
+ or <code class="computeroutput"><span class="identifier">t2</span><span class="special">()</span></code>,
+ ..., or <code class="computeroutput"><span class="identifier">e</span><span class="special">()</span></code>
+ depending on which meta-function <code class="computeroutput"><span class="identifier">Pred1</span><span class="special">::</span><span class="identifier">value</span></code>,
+ <code class="computeroutput"><span class="identifier">Pred2</span><span class="special">::</span><span class="identifier">value</span></code>, ... is statically evaluated to be
+ <code class="computeroutput"><span class="keyword">true</span></code> or <code class="computeroutput"><span class="keyword">false</span></code>
+ at compile-time, and it will return the value returned by the functor being
+ called. If <code class="computeroutput"><span class="identifier">t1</span></code>, <code class="computeroutput"><span class="identifier">t2</span></code>, ..., <code class="computeroutput"><span class="identifier">e</span></code>
+ are functor template instantiations (not just functors) then their code will
only be compiled if the compiler determines they need to be actually called
at run-time (so only if the related <code class="computeroutput"><span class="identifier">Pred1</span><span class="special">::</span><span class="identifier">value</span></code>,
<code class="computeroutput"><span class="identifier">Pred2</span><span class="special">::</span><span class="identifier">value</span></code>, ... are respectively evaluated to
otherwise it is required.
</p>
<p>
- The <code class="computeroutput"><a class="link" href="../boost/contract/condition_if_c.html" title="Function template condition_if_c">boost::contract::condition_if_c</a></code>,
+ In general, <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
+ can be used to program contract assertions that compile and check different
+ functor templates depending on related predicates being statically evaluated
+ to be <code class="computeroutput"><span class="keyword">true</span></code> or <code class="computeroutput"><span class="keyword">false</span></code> at compile-time (but in most cases
+ <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
+ should be sufficient and less verbose to use). The <code class="computeroutput"><a class="link" href="../boost/contract/condition_if_c.html" title="Function template condition_if_c">boost::contract::condition_if_c</a></code>,
<code class="computeroutput"><a class="link" href="../boost/contract/call_if_c.html" title="Function template call_if_c">boost::contract::call_if_c</a></code>,
and <code class="computeroutput"><span class="special">.</span><span class="identifier">else_if_c</span></code>
function templates work similarly to their counterparts without the <code class="computeroutput"><span class="special">...</span><span class="identifier">_c</span></code> postfix
boolean values instead of nullary boolean meta-functions.
</p>
<p>
- In general, <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
- can be used to program contract assertions that compile and check different
- functor templates depending on related predicates being statically evaluated
- to be <code class="computeroutput"><span class="keyword">true</span></code> or <code class="computeroutput"><span class="keyword">false</span></code> at compile-time (but in most cases
- <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
- should be sufficient and less verbose to use). On compilers that support
- C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
- there should be no need to use <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
+ On compilers that support C++17 <code class="computeroutput"><span class="keyword">if</span>
+ <span class="keyword">constexpr</span></code> there should be no need
+ to use <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
or <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
because <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
can be used instead (making the code more readable and easier to program).
- </p>
-<h5>
-<a name="boost_contract.extras.assertion_requirements__templates_.h0"></a>
- <span class="phrase"><a name="boost_contract.extras.assertion_requirements__templates_.if_constexpr_emulation__c__14_"></a></span><a class="link" href="extras.html#boost_contract.extras.assertion_requirements__templates_.if_constexpr_emulation__c__14_">If-Constexpr
- Emulation (C++14)</a>
- </h5>
-<p>
- A part from its use within contracts, on C++14 compilers <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
- can be used together with C++14 generic lambdas to emulate C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>.
- <a href="#ftn.boost_contract.extras.assertion_requirements__templates_.f2" class="footnote" name="boost_contract.extras.assertion_requirements__templates_.f2"><sup class="footnote">[71]</sup></a> For example (see <a href="../../../example/features/call_if_cxx14.cpp" target="_top"><code class="literal">call_if_cxx14.cpp</code></a>):
- </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
- <p>
- Until C++17 (without <code class="computeroutput"><span class="keyword">if</span>
- <span class="keyword">constexpr</span></code>)
- </p>
- </th>
-<th>
- <p>
- Since C++17 (with <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>)
- </p>
- </th>
-</tr></thead>
-<tbody><tr>
-<td>
- <p>
-</p>
-<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Iter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Dist</span><span class="special">></span>
-<span class="keyword">void</span> <span class="identifier">myadvance</span><span class="special">(</span><span class="identifier">Iter</span><span class="special">&</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">Dist</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
- <span class="identifier">Iter</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="special">&</span><span class="identifier">i</span><span class="special">;</span> <span class="comment">// So captures change actual pointed iterator value.</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">call_if</span><span class="special"><</span><span class="identifier">is_random_access_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">></span> <span class="special">>(</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">auto</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> <span class="comment">// C++14 generic lambda.</span>
- <span class="special">*</span><span class="identifier">p</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
- <span class="special">},</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span>
- <span class="special">).</span><span class="keyword">template</span> <span class="identifier">else_if</span><span class="special"><</span><span class="identifier">is_bidirectional_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">></span> <span class="special">>(</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">auto</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
- <span class="keyword">if</span><span class="special">(</span><span class="identifier">n</span> <span class="special">>=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++*</span><span class="identifier">p</span><span class="special">;</span>
- <span class="keyword">else</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">++)</span> <span class="special">--*</span><span class="identifier">p</span><span class="special">;</span>
- <span class="special">},</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span>
- <span class="special">).</span><span class="keyword">template</span> <span class="identifier">else_if</span><span class="special"><</span><span class="identifier">is_input_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">></span> <span class="special">>(</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">auto</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
- <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++*</span><span class="identifier">p</span><span class="special">;</span>
- <span class="special">},</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span>
- <span class="special">).</span><span class="identifier">else_</span><span class="special">(</span>
- <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">false_</span><span class="special">)</span> <span class="special">{</span>
- <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">false_</span><span class="special">,</span> <span class="string">"requires at least input iterator"</span><span class="special">);</span>
- <span class="special">},</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">false_type</span><span class="special">())</span> <span class="comment">// Use constexpr value.</span>
- <span class="special">);</span>
-<span class="special">}</span>
-</pre>
-<p>
- </p>
- </td>
-<td>
- <p>
-</p>
-<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Iter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Dist</span><span class="special">></span>
-<span class="keyword">void</span> <span class="identifier">myadvance</span><span class="special">(</span><span class="identifier">Iter</span><span class="special">&</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">Dist</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
- <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">is_random_access_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
- <span class="identifier">i</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
- <span class="special">}</span> <span class="keyword">else</span> <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">is_bidirectional_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
- <span class="keyword">if</span><span class="special">(</span><span class="identifier">n</span> <span class="special">>=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++</span><span class="identifier">i</span><span class="special">;</span>
- <span class="keyword">else</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">++)</span> <span class="special">--</span><span class="identifier">i</span><span class="special">;</span>
- <span class="special">}</span> <span class="keyword">else</span> <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">is_input_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
- <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++</span><span class="identifier">p</span><span class="special">;</span>
- <span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
- <span class="keyword">static_assert</span><span class="special">(</span><span class="keyword">false</span><span class="special">,</span> <span class="string">"requires at least input iterator"</span><span class="special">);</span>
- <span class="special">}</span>
-<span class="special">}</span>
-</pre>
-<p>
- </p>
- </td>
-</tr></tbody>
-</table></div>
-<p>
- This implementation is more concise, easier to read and maintain than the
- usual implementation of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">advance</span></code>
- that uses tag dispatching. Of course the implementation that uses C++17
- <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
- is even more readable and concise.
+ <a href="#ftn.boost_contract.extras.assertion_requirements__templates_.f2" class="footnote" name="boost_contract.extras.assertion_requirements__templates_.f2"><sup class="footnote">[72]</sup></a>
</p>
</div>
<div class="section">
for volatile public functions. These <span class="emphasis"><em>volatile class invariants</em></span>
are programmed in a public <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code> function, named <code class="computeroutput"><span class="identifier">invariant</span></code>,
taking no argument, and returning <code class="computeroutput"><span class="keyword">void</span></code>
- (see <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870579312.html" title="Macro BOOST_CONTRACT_INVARIANT_FUNC">BOOST_CONTRACT_INVARIANT_FUNC</a></code>
+ (see <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999724496.html" title="Macro BOOST_CONTRACT_INVARIANT_FUNC">BOOST_CONTRACT_INVARIANT_FUNC</a></code>
to name the invariant function differently from <code class="computeroutput"><span class="identifier">invariant</span></code>
and <a class="link" href="advanced.html#boost_contract.advanced.access_specifiers" title="Access Specifiers">Access Specifiers</a>
to not have to declare it <code class="computeroutput"><span class="keyword">public</span></code>).
<code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code>,
and <code class="computeroutput"><span class="keyword">const</span></code> invariant functions
(see <a class="link" href="tutorial.html#boost_contract.tutorial.class_invariants" title="Class Invariants">Class Invariants</a>):
- <a href="#ftn.boost_contract.extras.volatile_public_functions.f0" class="footnote" name="boost_contract.extras.volatile_public_functions.f0"><sup class="footnote">[72]</sup></a>
+ <a href="#ftn.boost_contract.extras.volatile_public_functions.f0" class="footnote" name="boost_contract.extras.volatile_public_functions.f0"><sup class="footnote">[73]</sup></a>
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
and non-<code class="computeroutput"><span class="keyword">const</span></code> public functions
will check only <code class="computeroutput"><span class="keyword">const</span></code> invariants,
correctly so because the <code class="computeroutput"><span class="keyword">volatile</span></code>
- qualifier shall not be stripped away): <a href="#ftn.boost_contract.extras.volatile_public_functions.f1" class="footnote" name="boost_contract.extras.volatile_public_functions.f1"><sup class="footnote">[73]</sup></a>
+ qualifier shall not be stripped away): <a href="#ftn.boost_contract.extras.volatile_public_functions.f1" class="footnote" name="boost_contract.extras.volatile_public_functions.f1"><sup class="footnote">[74]</sup></a>
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">u</span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="keyword">void</span> <span class="identifier">invariant</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span> <span class="comment">// Volatile invariants.</span>
<span class="keyword">void</span> <span class="identifier">invariant</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span>
- <span class="keyword">const_cast</span><span class="special"><</span><span class="identifier">u</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*>(</span><span class="keyword">this</span><span class="special">)-></span><span class="identifier">invariant</span><span class="special">();</span> <span class="comment">// Call `const volatile` invariant function above.</span>
+ <span class="keyword">auto</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="identifier">cv</span> <span class="special">=</span> <span class="keyword">this</span><span class="special">;</span> <span class="identifier">cv</span><span class="special">-></span><span class="identifier">invariant</span><span class="special">();</span> <span class="comment">// Call `const volatile` invariant function above.</span>
<span class="special">...</span> <span class="comment">// Other non-volatile invariants.</span>
<span class="special">}</span>
<p>
As with all public operations of a class, also public move operations should
maintain class invariants (see <a class="link" href="bibliography.html#Stroustrup13_anchor">[Stroustrup13]</a>,
- p. 520). Specifically, C++ requires the following:
+ p. 520). Specifically, at a minimum C++ requires the following:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
The moved-from object can be move assigned.
</li>
<li class="listitem">
- The moved-from object can be destroyed (if not for anything else, this
- requires that class invariants are maintained by move operations because
- the destructor of the moved-from object requires class invariants to
- be satisfied at its entry, as always with destructors see <a class="link" href="contract_programming_overview.html#boost_contract.contract_programming_overview.destructor_calls" title="Destructor Calls">Destructor
+ The moved-from object can be destroyed (if not for any other reason,
+ this requires that class invariants are maintained by move operations
+ because the destructor of the moved-from object requires class invariants
+
to be satisfied at its entry, as always with destructors see <a class="link" href="contract_programming_overview.html#boost_contract.contract_programming_overview.destructor_calls" title="Destructor Calls">Destructor
Calls</a>).
</li>
</ul></div>
Therefore, both the move constructor and the move assignment operator need
to maintain the class invariants of the moved-from object so their contracts
can be programmed using <code class="computeroutput"><a class="link" href="../boost/contract/constructor.html" title="Function template constructor">boost::contract::constructor</a></code>
- and <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45123869756752.html" title="Function template public_function">boost::contract::public_function</a></code>
+ and <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45394998885120.html" title="Function template public_function">boost::contract::public_function</a></code>
as usual. For example (see <a href="../../../example/features/move.cpp" target="_top"><code class="literal">move.cpp</code></a>):
</p>
<p>
<span class="special">}</span>
<span class="comment">// Move constructor.</span>
- <span class="comment">/* implicit */</span> <span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">circular_buffer</span><span class="special">&&</span> <span class="identifier">other</span><span class="special">)</span> <span class="special">:</span>
+ <span class="identifier">circular_buffer</span><span class="special">(</span><span class="identifier">circular_buffer</span><span class="special">&&</span> <span class="identifier">other</span><span class="special">)</span> <span class="special">:</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">constructor_precondition</span><span class="special"><</span><span class="identifier">circular_buffer</span><span class="special">>([&]</span> <span class="special">{</span>
<span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(!</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">moved</span><span class="special">());</span>
<span class="special">})</span>
</p>
<p>
This example assumes that it is possible to call the public function <code class="computeroutput"><span class="identifier">moved</span><span class="special">()</span></code>
- on the moved-from object. <a href="#ftn.boost_contract.extras.move_operations.f0" class="footnote" name="boost_contract.extras.move_operations.f0"><sup class="footnote">[74]</sup></a>
+ on the moved-from object. <a href="#ftn.boost_contract.extras.move_operations.f0" class="footnote" name="boost_contract.extras.move_operations.f0"><sup class="footnote">[75]</sup></a>
</p>
<div class="note"><table border="0" summary="Note">
<tr>
and their class has no invariants, programmers should manually define them
using <code class="computeroutput"><a class="link" href="../boost/contract/constructor.html" title="Function template constructor">boost::contract::constructor</a></code>,
<code class="computeroutput"><a class="link" href="../boost/contract/constructor_precondition.html" title="Class template constructor_precondition">boost::contract::constructor_precondition</a></code>,
- and <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45123869756752.html" title="Function template public_function">boost::contract::public_function</a></code>
+ and <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45394998885120.html" title="Function template public_function">boost::contract::public_function</a></code>
instead of relying on their default implementations generated by C++. (Same
as for all other operations automatically implemented by C++.)
</p></td></tr>
<p>
As always, programmers can decide to not program contracts for a given type.
Specifically, they might decide to not program contracts for a class that
- needs to be moved in order to skip the run-time overhead of checking contract
- assertions
to optimize performance (see <a class="link" href="contract_programming_overview.html#boost_contract.contract_programming_overview.benefits_and_costs" title="Benefits and Costs">Benefits
+ needs to be moved in order to avoid the run-time overhead of checking contract
+ assertions
and to maximize performance (see <a class="link" href="contract_programming_overview.html#boost_contract.contract_programming_overview.benefits_and_costs" title="Benefits and Costs">Benefits
and Costs</a>).
</p>
</div>
<a name="boost_contract.extras.unions"></a><a class="link" href="extras.html#boost_contract.extras.unions" title="Unions">Unions</a>
</h3></div></div></div>
<p>
- In C++, a <code class="computeroutput"><span class="keyword">union</span></code> cannot have
- virtual functions, bases classes, and cannot be used as a base class thus
-
subcontracting (<code class="computeroutput"><a class="link" href="../boost/contract/virtual_.html" title="Class virtual_">boost::contract::virtual_</a></code>,
+ A C++ <code class="computeroutput"><span class="keyword">union</span></code> cannot have virtual
+ functions, base classes, and cannot be used as a base class thus subcontracting
+ (<code class="computeroutput"><a class="link" href="../boost/contract/virtual_.html" title="Class virtual_">boost::contract::virtual_</a></code>,
<code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDE.html" title="Macro BOOST_CONTRACT_OVERRIDE">BOOST_CONTRACT_OVERRIDE</a></code>,
etc.) do not apply to unions. Also a <code class="computeroutput"><span class="keyword">union</span></code>
cannot inherit from <code class="computeroutput"><a class="link" href="../boost/contract/constructor_precondition.html" title="Class template constructor_precondition">boost::contract::constructor_precondition</a></code>
- (because it cannot have base classes) so such a class is used to declare
- a local object that checks constructor preconditions (at the very beginning
- of the constructor before old value copies and other contracts, see declaration
- of <code class="computeroutput"><span class="identifier">pre</span></code> in the example below).
- A part from that, this library is used as usual to program contracts for
- unions. For example (see <a href="../../../example/features/union.cpp" target="_top"><code class="literal">union.cpp</code></a>):
+ (because it cannot have base classes), instead <code class="computeroutput"><a class="link" href="../boost/contract/constructor_precondition.html" title="Class template constructor_precondition">boost::contract::constructor_precondition</a></code>
+ is used to declare a local object that checks constructor preconditions (at
+ the very beginning of the constructor before old value copies and other contracts,
+ see declaration of <code class="computeroutput"><span class="identifier">pre</span></code> in
+ the example below). A part from that, this library is used as usual to program
+
contracts for unions. For example (see <a href="../../../example/features/union.cpp" target="_top"><code class="literal">union.cpp</code></a>):
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">union</span> <span class="identifier">positive</span> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
- <span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">static_invariant</span><span class="special">()</span> <span class="special">{</span> <span class="comment">// Static class invariants.</span>
+ <span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">static_invariant</span><span class="special">()</span> <span class="special">{</span> <span class="comment">// Static class invariants (as usual).</span>
<span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">instances</span><span class="special">()</span> <span class="special">>=</span> <span class="number">0</span><span class="special">);</span>
<span class="special">}</span>
- <span class="keyword">void</span> <span class="identifier">invariant</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span> <span class="comment">// Class invariants.</span>
+ <span class="keyword">void</span> <span class="identifier">invariant</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span> <span class="comment">// Class invariants (as usual).</span>
<span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">i_</span> <span class="special">></span> <span class="number">0</span><span class="special">);</span>
<span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">d_</span> <span class="special">></span> <span class="number">0</span><span class="special">);</span>
<span class="special">}</span>
<span class="comment">// Contracts for constructor, as usual but...</span>
- <span class="keyword">explicit</span> <span class="identifier">positive</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">explicit</span> <span class="identifier">positive</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">d_</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">{</span>
<span class="comment">// ...unions cannot have bases so constructor preconditions here.</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">constructor_precondition</span><span class="special"><</span><span class="identifier">positive</span><span class="special">></span> <span class="identifier">pre</span><span class="special">([&]</span> <span class="special">{</span>
<span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">x</span> <span class="special">></span> <span class="number">0</span><span class="special">);</span>
<span class="identifier">BOOST_CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">instances</span><span class="special">());</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">constructor</span><span class="special">(</span><span class="keyword">this</span><span class="special">)</span>
<span class="special">.</span><span class="identifier">postcondition</span><span class="special">([&]</span> <span class="special">{</span>
+ <span class="special">{</span> <span class="keyword">int</span> <span class="identifier">y</span><span class="special">;</span> <span class="identifier">get</span><span class="special">(</span><span class="identifier">y</span><span class="special">);</span> <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="identifier">x</span><span class="special">);</span> <span class="special">}</span>
<span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">instances</span><span class="special">()</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">old_instances</span> <span class="special">+</span> <span class="number">1</span><span class="special">);</span>
<span class="special">})</span>
<span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Contracts for public function (as usual, but no virtual or override).</span>
- <span class="keyword">void</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">int</span><span class="special">&</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">void</span> <span class="identifier">get</span><span class="special">(</span><span class="keyword">int</span><span class="special">&</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">public_function</span><span class="special">(</span><span class="keyword">this</span><span class="special">)</span>
<span class="special">.</span><span class="identifier">postcondition</span><span class="special">([&]</span> <span class="special">{</span>
<span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">x</span> <span class="special">></span> <span class="number">0</span><span class="special">);</span>
- <span class="special">});</span>
+ <span class="special">})</span>
<span class="special">;</span>
<span class="identifier">x</span> <span class="special">=</span> <span class="identifier">i_</span><span class="special">;</span>
<p>
This library provides three predefined <span class="emphasis"><em>assertion levels</em></span>
that can be used to selectively disable assertions depending on their computational
- complexity: <a href="#ftn.boost_contract.extras.assertion_levels.f0" class="footnote" name="boost_contract.extras.assertion_levels.f0"><sup class="footnote">[75]</sup></a>
+ complexity: <a href="#ftn.boost_contract.extras.assertion_levels.f0" class="footnote" name="boost_contract.extras.assertion_levels.f0"><sup class="footnote">[76]</sup></a>
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
<code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_ASSERT.html" title="Macro BOOST_CONTRACT_ASSERT">BOOST_CONTRACT_ASSERT</a></code>
is used to assert conditions that are not computationally expensive,
at least compared to the cost of executing the function body. These assertions
- are always checked at run-time, they are not disabled.
+ are the ones we have seen so far, they are always checked at run-time
+ and they cannot be disabled.
</li>
<li class="listitem">
- <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123871181520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
+ <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395000817520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
is used to assert conditions that are computationally expensive compared
to the cost of executing the function body. These assertions are not
checked at run-time unless programmers explicitly define <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_AUDITS.html" title="Macro BOOST_CONTRACT_AUDITS">BOOST_CONTRACT_AUDITS</a></code>
- (undefined by default), but the conditions are always compiled and validated
- syntactically (even when they are not actually evaluated and checked
- at run-time).
+ (undefined by default), but the asserted conditions are always compiled
+ and therefore validated syntactically (even when they are not actually
+ evaluated and checked at run-time).
</li>
<li class="listitem">
- <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123897980656.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
+ <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395027441616.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
is used to assert conditions that are computationally prohibitive, at
least compared to the cost of executing the function body. These assertions
are never evaluated or checked at run-time, but the asserted conditions
- are always compiled and validated syntactically so these assertions can
- serve as formal comments in the code.
+ are always compiled and therefore validated syntactically (so these assertions
+ can serve as formal comments to the code).
</li>
</ul></div>
<p>
In addition, <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_CHECK_AUDIT.html" title="Macro BOOST_CONTRACT_CHECK_AUDIT">BOOST_CONTRACT_CHECK_AUDIT</a></code>
and <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_CHECK_AXIOM.html" title="Macro BOOST_CONTRACT_CHECK_AXIOM">BOOST_CONTRACT_CHECK_AXIOM</a></code>
- are similar to <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123871181520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123897980656.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
+ are similar to <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395000817520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395027441616.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
but they are used to program audit and axiom levels for implementation checks
instead of assertions (see <a class="link" href="advanced.html#boost_contract.advanced.implementation_checks" title="Implementation Checks">Implementation
Checks</a>).
</p>
<p>
- For example, <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123871181520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
+ For example, <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395000817520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
can be used to program computationally expensive assertions (see <a href="../../../example/features/assertion_level.cpp" target="_top"><code class="literal">assertion_level.cpp</code></a>):
</p>
<p>
<p>
</p>
<p>
- The condition passed to <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123897980656.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
+ The condition passed to <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395027441616.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
is compiled but not actually evaluated at run-time so this macro can be used
to program computationally prohibitive assertions but also assertions that
cannot actually be programmed in C++ using functions that are declared but
<p>
</p>
<p>
- In addition to the assertion levels predefined by this library, programmers
- are free to define their own. For example, the following macro could be used
- to program and selectively disable assertions that have exponential computational
- complexity <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">e</span><span class="special">^</span><span class="identifier">n</span><span class="special">)</span></code>:
+ In addition to these assertion levels that are predefined by this library,
+ programmers are free to define their own. For example, the following macro
+ could be used to program and selectively disable assertions that have exponential
+ computational complexity <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">e</span><span class="special">^</span><span class="identifier">n</span><span class="special">)</span></code>:
</p>
-<pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">NO_EXPONENTIALLY_COMPLEX_ASSERTIONS</span>
- <span class="comment">// Following will compile but never actually evaluate `cond`.</span>
- <span class="preprocessor">#define</span> <span class="identifier">EXP_ASSERTION</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span> <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="keyword">true</span> <span class="special">||</span> <span class="special">(</span><span class="identifier">cond</span><span class="special">))</span>
-<span class="preprocessor">#else</span>
+<pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">EXPONENTIALLY_COMPLEX_ASSERTIONS</span>
<span class="comment">// Following will compile and also evaluate `cond`.</span>
- <span class="preprocessor">#define</span> <span class="identifier">EXP_ASSERTION</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span> <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span>
+ <span class="preprocessor">#define</span> <span class="identifier">ASSERT_EXP</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span> <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span>
+<span class="preprocessor">#else</span>
+ <span class="comment">// Following will compile but never actually evaluate `cond`.</span>
+ <span class="preprocessor">#define</span> <span class="identifier">ASSERT_EXP</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span> <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="keyword">true</span> <span class="special">||</span> <span class="special">(</span><span class="identifier">cond</span><span class="special">))</span>
<span class="preprocessor">#endif</span>
<span class="special">...</span>
-<span class="identifier">EXP_ASSERTION</span><span class="special">(</span><code class="literal"><span class="emphasis"><em>some-exponentially-complex-boolean-condition</em></span></code><span class="special">);</span>
+<span class="identifier">ASSERT_EXP</span><span class="special">(</span><code class="literal"><span class="emphasis"><em>some-exponentially-complex-boolean-condition</em></span></code><span class="special">);</span>
</pre>
</div>
<div class="section">
and Costs</a>). Therefore, programmers can define any combination of the
following macros (<code class="computeroutput"><span class="special">-</span><span class="identifier">D</span></code>
option in Clang and GCC, <code class="computeroutput"><span class="special">/</span><span class="identifier">D</span></code>
- option in MSVC, etc.) to instruct this library to not check specific kind
+ option in MSVC, etc.) to instruct this library to not check specific groups
of contract conditions at run-time:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
- Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870517808.html" title="Macro BOOST_CONTRACT_NO_PRECONDITIONS">BOOST_CONTRACT_NO_PRECONDITIONS</a></code>
+ Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999662416.html" title="Macro BOOST_CONTRACT_NO_PRECONDITIONS">BOOST_CONTRACT_NO_PRECONDITIONS</a></code>
to not check preconditions.
</li>
<li class="listitem">
- Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870511440.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>
+ Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999656032.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>
to not check postconditions.
</li>
<li class="listitem">
to not check exception guarantees.
</li>
<li class="listitem">
- Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870492704.html" title="Macro BOOST_CONTRACT_NO_ENTRY_INVARIANTS">BOOST_CONTRACT_NO_ENTRY_INVARIANTS</a></code>
+ Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999637264.html" title="Macro BOOST_CONTRACT_NO_ENTRY_INVARIANTS">BOOST_CONTRACT_NO_ENTRY_INVARIANTS</a></code>
to not check class invariants at call entry.
</li>
<li class="listitem">
- Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870485088.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>
+ Define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999629648.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>
to not check class invariants at call exit.
</li>
<li class="listitem">
- Or, define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870477472.html" title="Macro BOOST_CONTRACT_NO_INVARIANTS">BOOST_CONTRACT_NO_INVARIANTS</a></code>
+ Or, define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999622032.html" title="Macro BOOST_CONTRACT_NO_INVARIANTS">BOOST_CONTRACT_NO_INVARIANTS</a></code>
to not check class invariants at both call entry and exit. (This is provided
- for convenience, it is equivalent to define both <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870492704.html" title="Macro BOOST_CONTRACT_NO_ENTRY_INVARIANTS">BOOST_CONTRACT_NO_ENTRY_INVARIANTS</a></code>
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870485088.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>.)
+ for convenience, it is equivalent to defining both <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999637264.html" title="Macro BOOST_CONTRACT_NO_ENTRY_INVARIANTS">BOOST_CONTRACT_NO_ENTRY_INVARIANTS</a></code>
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999629648.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>.)
</li>
<li class="listitem">
Define <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_NO_CHECKS.html" title="Macro BOOST_CONTRACT_NO_CHECKS">BOOST_CONTRACT_NO_CHECKS</a></code>
- to not perform implementation checks.
+ to not evaluate implementation checks.
</li>
</ul></div>
<div class="note"><table border="0" summary="Note">
</tr>
<tr><td align="left" valign="top"><p>
Old values can be used by both postconditions and exception guarantees
- so it is necessary to define both <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870511440.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>
+ so it is necessary to define both <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999656032.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>
and <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_NO_EXCEPTS.html" title="Macro BOOST_CONTRACT_NO_EXCEPTS">BOOST_CONTRACT_NO_EXCEPTS</a></code>
to disable old value copies.
</p></td></tr>
and compile-time overhead associated with checking and compiling contracts
(see <a class="link" href="extras.html#boost_contract.extras.disable_contract_compilation__macro_interface_" title="Disable Contract Compilation (Macro Interface)">Disable
Contract Compilation</a> for techniques to completely remove any run-time
- and compile-time overhead associated with contract code).
+ and compile-time overheads associated with contract code).
</p>
<p>
For example, programmers could decide to check all contracts during early
development builds, but later check only preconditions and maybe entry invariants
- for release builds by defining <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870511440.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>,
+ for release builds by defining <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999656032.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_NO_EXCEPTS.html" title="Macro BOOST_CONTRACT_NO_EXCEPTS">BOOST_CONTRACT_NO_EXCEPTS</a></code>,
- <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870485088.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>,
+ <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999629648.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>,
and <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_NO_CHECKS.html" title="Macro BOOST_CONTRACT_NO_CHECKS">BOOST_CONTRACT_NO_CHECKS</a></code>.
</p>
</div>
<p>
This library provides macros that can be used to completely disable compile-time
and run-time overhead introduced by contracts but at the cost of manually
- programming <code class="computeroutput"><span class="preprocessor">#ifndef</span></code> statements
- around contract code:
+ programming <code class="computeroutput"><span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code> statements around contract code:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
- This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870460880.html" title="Macro BOOST_CONTRACT_NO_CONSTRUCTORS">BOOST_CONTRACT_NO_CONSTRUCTORS</a></code>
+ This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999605408.html" title="Macro BOOST_CONTRACT_NO_CONSTRUCTORS">BOOST_CONTRACT_NO_CONSTRUCTORS</a></code>
when contract checking is disabled for constructors.
</li>
<li class="listitem">
- This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870450032.html" title="Macro BOOST_CONTRACT_NO_DESTRUCTORS">BOOST_CONTRACT_NO_DESTRUCTORS</a></code>
+ This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999594544.html" title="Macro BOOST_CONTRACT_NO_DESTRUCTORS">BOOST_CONTRACT_NO_DESTRUCTORS</a></code>
when contract checking is disabled for destructors.
</li>
<li class="listitem">
- This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870441776.html" title="Macro BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS">BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS</a></code>
+ This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999586272.html" title="Macro BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS">BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS</a></code>
when contract checking is disabled for public functions.
</li>
<li class="listitem">
- This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870432592.html" title="Macro BOOST_CONTRACT_NO_FUNCTIONS">BOOST_CONTRACT_NO_FUNCTIONS</a></code>
+ This library defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999577072.html" title="Macro BOOST_CONTRACT_NO_FUNCTIONS">BOOST_CONTRACT_NO_FUNCTIONS</a></code>
when contract checking is disabled for (non-public and non-member) functions.
</li>
<li class="listitem">
</ul></div>
<p>
These macros are not configuration macros and they should not be defined
- directly by programmers (otherwise this library will generate a compile-time
- error). Instead, these macros are automatically defined by this library when
- programmers define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870517808.html" title="Macro BOOST_CONTRACT_NO_PRECONDITIONS">BOOST_CONTRACT_NO_PRECONDITIONS</a></code>,
- <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870511440.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>,
+ directly by programmers (otherwise this library will generate compile-time
+ errors). Instead, these macros are automatically defined by this library
+ when programmers define <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999662416.html" title="Macro BOOST_CONTRACT_NO_PRECONDITIONS">BOOST_CONTRACT_NO_PRECONDITIONS</a></code>,
+ <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999656032.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_NO_EXCEPTS.html" title="Macro BOOST_CONTRACT_NO_EXCEPTS">BOOST_CONTRACT_NO_EXCEPTS</a></code>,
- <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870477472.html" title="Macro BOOST_CONTRACT_NO_INVARIANTS">BOOST_CONTRACT_NO_INVARIANTS</a></code>
- (or <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870492704.html" title="Macro BOOST_CONTRACT_NO_ENTRY_INVARIANTS">BOOST_CONTRACT_NO_ENTRY_INVARIANTS</a></code>
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870485088.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>),
+ <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999622032.html" title="Macro BOOST_CONTRACT_NO_INVARIANTS">BOOST_CONTRACT_NO_INVARIANTS</a></code>
+ (or <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999637264.html" title="Macro BOOST_CONTRACT_NO_ENTRY_INVARIANTS">BOOST_CONTRACT_NO_ENTRY_INVARIANTS</a></code>
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999629648.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>),
and <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_NO_CHECKS.html" title="Macro BOOST_CONTRACT_NO_CHECKS">BOOST_CONTRACT_NO_CHECKS</a></code>
(see <a class="link" href="extras.html#boost_contract.extras.disable_contract_checking" title="Disable Contract Checking">Disable
Contract Checking</a>).
</p>
<p>
- Alternatively, this library provides a macro-based interface <code class="computeroutput"><a class="link" href="../reference.html#header.boost.contract_macro_hpp" title="Header <boost/contract_macro.hpp>">boost/contract_macro.hpp</a></code> that
- can also be used to completely disable compile-time and run-time overhead
- introduced by contracts. For example, the following code shows how to use
- both the macro interface and the <code class="computeroutput"><span class="preprocessor">#ifndef</span>
+ Alternatively, this library provides a macro-based interface defined in
+ <code class="computeroutput"><a class="link" href="../reference.html#header.boost.contract_macro_hpp" title="Header <boost/contract_macro.hpp>">boost/contract_macro.hpp</a></code>
+ that can also be used to completely disable compile-time and run-time overheads
+ introduced by contracts but without the burden of manually writing the <code class="computeroutput"><span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code> statements. For example, the following
+ code shows how to use both the <code class="computeroutput"><a class="link" href="../reference.html#header.boost.contract_macro_hpp" title="Header <boost/contract_macro.hpp>">boost/contract_macro.hpp</a></code>
+ macro interface and the <code class="computeroutput"><span class="preprocessor">#ifndef</span>
<span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code>
- statements to completely disable compile-time and run-time overhead for non-member
- function contracts (see <a href="../../../example/features/ifdef_macro.cpp" target="_top"><code class="literal">ifdef_macro.cpp</code></a>
+ statements to completely disable compile-time and run-time overheads for
+
non-member function contracts (see <a href="../../../example/features/ifdef_macro.cpp" target="_top"><code class="literal">ifdef_macro.cpp</code></a>
and <a href="../../../example/features/ifdef.cpp" target="_top"><code class="literal">ifdef.cpp</code></a>):
</p>
<div class="informaltable"><table class="table">
</table></div>
<p>
The same can be done to disable contract code complication for private and
- protected functions. The <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123869551136.html" title="Macro BOOST_CONTRACT_OLD_PTR_IF_COPYABLE">BOOST_CONTRACT_OLD_PTR_IF_COPYABLE</a></code>
+ protected functions. The <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394998674080.html" title="Macro BOOST_CONTRACT_OLD_PTR_IF_COPYABLE">BOOST_CONTRACT_OLD_PTR_IF_COPYABLE</a></code>
macro is provided to handle non-copyable old value types (similar to <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>).
- For constructors, destructors, and public functions instead (see <a href="../../../example/features/ifdef_macro.cpp" target="_top"><code class="literal">ifdef_macro.cpp</code></a>
+ </p>
+<p>
+ For constructors, destructors, and public functions the <code class="computeroutput"><a class="link" href="../reference.html#header.boost.contract_macro_hpp" title="Header <boost/contract_macro.hpp>">boost/contract_macro.hpp</a></code>
+ macro interface and the <code class="computeroutput"><span class="preprocessor">#ifndef</span>
+ <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code>
+ statements can be used as follow (see <a href="../../../example/features/ifdef_macro.cpp" target="_top"><code class="literal">ifdef_macro.cpp</code></a>
and <a href="../../../example/features/ifdef.cpp" target="_top"><code class="literal">ifdef.cpp</code></a>):
</p>
<div class="informaltable"><table class="table">
</tr></tbody>
</table></div>
<p>
- Static and volatile class invariants can be programmed using <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123869498768.html" title="Macro BOOST_CONTRACT_STATIC_INVARIANT">BOOST_CONTRACT_STATIC_INVARIANT</a></code>
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123869512624.html" title="Macro BOOST_CONTRACT_INVARIANT_VOLATILE">BOOST_CONTRACT_INVARIANT_VOLATILE</a></code>
+ Static and volatile class invariants can be programmed using <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394998621472.html" title="Macro BOOST_CONTRACT_STATIC_INVARIANT">BOOST_CONTRACT_STATIC_INVARIANT</a></code>
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394998635328.html" title="Macro BOOST_CONTRACT_INVARIANT_VOLATILE">BOOST_CONTRACT_INVARIANT_VOLATILE</a></code>
respectively (these macros expand code equivalent to the <code class="computeroutput"><span class="keyword">static</span>
<span class="keyword">void</span> <span class="identifier">BOOST_CONTRACT_STATIC_INVARIANT_FUNC</span><span class="special">()</span></code> and <code class="computeroutput"><span class="keyword">void</span>
<span class="identifier">BOOST_CONTRACT_INVARIANT_FUNC</span><span class="special">()</span>
functions).
</p>
<p>
- The macro interface is usually preferred because more concise and easier
- to use than programming <code class="computeroutput"><span class="preprocessor">#ifndef</span>
- <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code>
+ The <code class="computeroutput"><a class="link" href="../reference.html#header.boost.contract_macro_hpp" title="Header <boost/contract_macro.hpp>">boost/contract_macro.hpp</a></code>
+ macro interface is usually preferred because more concise and easier to use
+ than programming <code class="computeroutput"><span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code>
statements by hand. However, C++ macros expand on a single line of code and
- that can make compiler errors less useful when using the macro interface
+ that can make compiler errors less useful when using this macro interface
plus all contract assertions within a given set of preconditions, postconditions,
exception guarantees, and class invariants will list the same line number
in error messages when assertions fail at run-time (but error messages still
- list the assertion code and that should allow programmers to identify the
- specific assertion that failed). Finally, the macro interface leaves a bit
- of contract decorations in the code but that should add no measurable compile-time
-
and run-time overhead (specifically, extra <code class="computeroutput"><a class="link" href="../boost/contract/virtual_.html" title="Class virtual_">boost::contract::virtual_</a></code><code class="computeroutput"><span class="special">*</span></code> parameters, calls to <code class="computeroutput"><a class="link" href="../boost/contract/constructor_precondition.html" title="Class template constructor_precondition">boost::contract::constructor_precondition</a></code>
+ list the assertion code and that should still allow programmers to identify
+ the specific assertion that failed). Finally, the macro interface leaves
+ a bit of contract decorations in the code but that should add no measurable
+
compile-time or run-time overhead (specifically, extra <code class="computeroutput"><a class="link" href="../boost/contract/virtual_.html" title="Class virtual_">boost::contract::virtual_</a></code><code class="computeroutput"><span class="special">*</span></code> parameters, calls to <code class="computeroutput"><a class="link" href="../boost/contract/constructor_precondition.html" title="Class template constructor_precondition">boost::contract::constructor_precondition</a></code>
default constructor which does nothing, <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_BASE_TYPES.html" title="Macro BOOST_CONTRACT_BASE_TYPES">BOOST_CONTRACT_BASE_TYPES</a></code>
<code class="computeroutput"><span class="keyword">typedef</span></code>s, and <code class="computeroutput"><a class="link" href="../boost/contract/access.html" title="Class access">boost::contract::access</a></code>
- friendships are left in user code even when contracts are disabled).
+ friendships are left in user code even when contracts are disabled unless
+ <code class="computeroutput"><span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code> statements are used).
</p>
<p>
Disabling contract as shown in <a class="link" href="extras.html#boost_contract.extras.disable_contract_checking" title="Disable Contract Checking">Disable
Usually, if the overhead of checking preconditions and other assertions is
already considered acceptable for an application then the compile-time overhead
of contracts should not represent an issue and it should be sufficient to
- be able to disable contract checking at run-time as indicated in <a class="link" href="extras.html#boost_contract.extras.disable_contract_checking" title="Disable Contract Checking">Disable
- Contract Checking</a> (without a real need to use the macro interface
- or the <code class="computeroutput"><span class="preprocessor">#ifndef</span> <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code> statements in most cases).
+ disable contract checking at run-time as indicated in <a class="link" href="extras.html#boost_contract.extras.disable_contract_checking" title="Disable Contract Checking">Disable
+ Contract Checking</a> (without a real need to use the <code class="computeroutput"><a class="link" href="../reference.html#header.boost.contract_macro_hpp" title="Header <boost/contract_macro.hpp>">boost/contract_macro.hpp</a></code>
+ macro interface or the <code class="computeroutput"><span class="preprocessor">#ifndef</span>
+ <span class="identifier">BOOST_CONTRACT_NO_</span><span class="special">...</span></code>
+ statements in most cases).
</p>
</div>
<div class="section">
in the object files, users will not be able to see the contract code to understand
semantics and usage of the functions (again, this might not be a real problem
in practice for example if contracts are already somehow extracted from the
- source code by some toll and presented as part of the documentation of the
+ source code by some tool and presented as part of the documentation of the
shipped software).
</p>
<p>
In any case, when it is truly important to separate contracts from function
implementation code, function implementations can be programmed in extra
- <span class="emphasis"><em>body functions</em></span> (e.g., named <code class="computeroutput"><span class="special">...</span><span class="identifier">_body</span></code>) that are compiled in object files.
- Function definitions that remain in header files instead will contain just
- contract code followed by calls the extra body functions. This technique
- allows to keep the contract code in header files while separating the implementation
- code to object files. However, it adds the overhead of manually programming
- an extra function declaration for the body function (plus the limitation
- that constructor member initialization lists must be programmed in header
- files because that is where constructors need to be defined to list constructor
- contract code). <a href="#ftn.boost_contract.extras.separate_body_implementation.f0" class="footnote" name="boost_contract.extras.separate_body_implementation.f0"><sup class="footnote">[76]</sup></a>
+ <span class="emphasis"><em>body functions</em></span> (here named <code class="computeroutput"><span class="special">...</span><span class="identifier">_body</span></code>, but any other naming scheme could
+ be used) that are compiled in object files. Function definitions that remain
+ in header files instead will contain just contract code followed by calls
+ to the extra body functions. This technique allows to keep the contract code
+ in header files while separating the implementation code to source and object
+ files. However, this adds the overhead of manually programming an extra function
+ declaration for each body function (plus the limitation that constructor
+ member initialization lists must be programmed in header files because that
+ is where constructors need to be defined to list constructor contract code).
+ <a href="#ftn.boost_contract.extras.separate_body_implementation.f0" class="footnote" name="boost_contract.extras.separate_body_implementation.f0"><sup class="footnote">[77]</sup></a>
</p>
<p>
For example, the following header file only contains function declarations,
<p>
</p>
<p>
- The same technique can be used for non-member, private, protectee functions,
+ The same technique can be used for non-member, private, and protected functions,
etc.
</p>
<div class="note"><table border="0" summary="Note">
also all this library headers are <code class="computeroutput"><span class="preprocessor">#include</span></code>d
only from <code class="literal">.cpp</code> files, then these <code class="literal">.cpp</code>
files can be compiled disabling specific contract checking (for example,
- <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870511440.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>,
+ <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999656032.html" title="Macro BOOST_CONTRACT_NO_POSTCONDITIONS">BOOST_CONTRACT_NO_POSTCONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_NO_EXCEPTS.html" title="Macro BOOST_CONTRACT_NO_EXCEPTS">BOOST_CONTRACT_NO_EXCEPTS</a></code>,
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123870485088.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>,
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394999629648.html" title="Macro BOOST_CONTRACT_NO_EXIT_INVARIANTS">BOOST_CONTRACT_NO_EXIT_INVARIANTS</a></code>,
see <a class="link" href="extras.html#boost_contract.extras.disable_contract_checking" title="Disable Contract Checking">Disable
Contract Checking</a>). Then the code in these <code class="literal">.cpp</code>
files will always have such contract checking disabled even when linked
It allows to use this library on compilers that do not support C++11
lambda functions (essentially most C++03 compilers with adequate support
for SFINAE can be used in that case, see <a class="link" href="extras.html#boost_contract.extras.no_macros__and_no_variadic_macros_" title="No Macros (and No Variadic Macros)">No
- Macros</a> to also avoid using variadic macros).
+ Macros</a> to also avoid using variadic macros). <a href="#ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f0" class="footnote" name="boost_contract.extras.no_lambda_functions__no_c__11_.f0"><sup class="footnote">[78]</sup></a>
</li>
<li class="listitem">
Contract functions (i.e., the <code class="computeroutput"><span class="special">...</span><span class="identifier">_precondition</span></code>, <code class="computeroutput"><span class="special">...</span><span class="identifier">_old</span></code>, and <code class="computeroutput"><span class="special">...</span><span class="identifier">_postcondition</span></code> functions in the example
below) can be programmed to fully enforce constant-correctness and other
contract requirements at compile-time (see <a class="link" href="contract_programming_overview.html#boost_contract.contract_programming_overview.constant_correctness" title="Constant-Correctness">Constant-Correctness</a>).
- <a href="#ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f0" class="footnote" name="boost_contract.extras.no_lambda_functions__no_c__11_.f0"><sup class="footnote">[77]</sup></a>
+ <a href="#ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f1" class="footnote" name="boost_contract.extras.no_lambda_functions__no_c__11_.f1"><sup class="footnote">[79]</sup></a>
</li>
<li class="listitem">
Code of the contract functions is separated from function body implementations
(see <a class="link" href="extras.html#boost_contract.extras.separate_body_implementation" title="Separate Body Implementation">Separate
- Body Implementation</a>). <a href="#ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f1" class="footnote" name="boost_contract.extras.no_lambda_functions__no_c__11_.f1"><sup class="footnote">[78]</sup></a>
+ Body Implementation</a>).
</li>
</ul></div>
<p>
However, not using C++11 lambda functions comes at the significant cost of
having to manually program the extra contract functions and related boiler-plate
- code. For example (see <a href="../../../example/features/no_lambdas.hpp" target="_top"><code class="literal">no_lambdas.hpp</code></a>
- and <a href="../../../example/features/no_lambdas.cpp" target="_top"><code class="literal">no_lambdas.cpp</code></a>):
+ code. For example, the header file (see <a href="../../../example/features/no_lambdas.hpp" target="_top"><code class="literal">no_lambdas.hpp</code></a>):
</p>
<p>
</p>
<p>
</p>
<p>
+ And, the source file (see <a href="../../../example/features/no_lambdas.cpp" target="_top"><code class="literal">no_lambdas.cpp</code></a>):
+ </p>
+<p>
</p>
<pre class="programlisting"><span class="identifier">iarray</span><span class="special">::</span><span class="identifier">iarray</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="identifier">max</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">count</span><span class="special">)</span> <span class="special">:</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">constructor_precondition</span><span class="special"><</span><span class="identifier">iarray</span><span class="special">>(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span>
or <code class="computeroutput"><span class="keyword">const</span></code> functions.
</li>
<li class="listitem">
- Constructor precondition, old value, and exception guarantee functions
+ For constructors: Precondition, old value, and exception guarantee functions
should be <code class="computeroutput"><span class="keyword">static</span></code> (because
there is no valid object <code class="computeroutput"><span class="keyword">this</span></code>
if the constructor body does not run successfully, see <a class="link" href="contract_programming_overview.html#boost_contract.contract_programming_overview.constructor_calls" title="Constructor Calls">Constructor
Calls</a>).
</li>
<li class="listitem">
- Destructor postcondition functions should be <code class="computeroutput"><span class="keyword">static</span></code>
+ For destructors: Postcondition functions should be <code class="computeroutput"><span class="keyword">static</span></code>
(because there is no valid object <code class="computeroutput"><span class="keyword">this</span></code>
after the destructor body runs successfully, but exception guarantee
functions do not have to be <code class="computeroutput"><span class="keyword">static</span></code>
in the header file while all function bodies are implemented in a separate
source file (including the constructor member initialization list, that could
not be done with the techniques shown in <a class="link" href="extras.html#boost_contract.extras.separate_body_implementation" title="Separate Body Implementation">Separate
- Body Implementation</a>). <a href="#ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f2" class="footnote" name="boost_contract.extras.no_lambda_functions__no_c__11_.f2"><sup class="footnote">[79]</sup></a> Also note that the contract functions can always be declared
+ Body Implementation</a>). <a href="#ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f2" class="footnote" name="boost_contract.extras.no_lambda_functions__no_c__11_.f2"><sup class="footnote">[80]</sup></a> Also note that the contract functions can always be declared
<code class="computeroutput"><span class="keyword">private</span></code> if programmers need
to exactly control the public members of the class (this was not done in
this example only for brevity).
</p>
<p>
The authors think this library is most useful when used together with C++11
- lambda functions.
+ lambda functions (because of the large amount of boiler-plate code required
+ when C++11 lambdas are not used as also shown by the example above).
</p>
</div>
<div class="section">
by this library and programming the related code manually instead (the only
macros that cannot be programmed manually are <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDE.html" title="Macro BOOST_CONTRACT_OVERRIDE">BOOST_CONTRACT_OVERRIDE</a></code>,
<code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDES.html" title="Macro BOOST_CONTRACT_OVERRIDES">BOOST_CONTRACT_OVERRIDES</a></code>,
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123869781472.html" title="Macro BOOST_CONTRACT_NAMED_OVERRIDE">BOOST_CONTRACT_NAMED_OVERRIDE</a></code>).
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394998912688.html" title="Macro BOOST_CONTRACT_NAMED_OVERRIDE">BOOST_CONTRACT_NAMED_OVERRIDE</a></code>).
</p>
<div class="note"><table border="0" summary="Note">
<tr>
all compilers that support C++11 lambda functions should also support C++11
variadic macros (and this library might rarely be used without the convenience
of C++11 lambda functions, see <a class="link" href="extras.html#boost_contract.extras.no_lambda_functions__no_c__11_" title="No Lambda Functions (No C++11)">No
- Lambda Functions</a>). <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f0" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f0"><sup class="footnote">[80]</sup></a> Therefore, the rest of this section can be considered mainly
+ Lambda Functions</a>). <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f0" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f0"><sup class="footnote">[81]</sup></a> Therefore, the rest of this section can be considered mainly
a curiosity because programmers should seldom, if ever, need to use this
library without using its macros.
</p></td></tr>
As shown in <a class="link" href="tutorial.html#boost_contract.tutorial.public_function_overrides__subcontracting_" title="Public Function Overrides (Subcontracting)">Public
Function Overrides</a> and <a class="link" href="advanced.html#boost_contract.advanced.named_overrides" title="Named Overrides">Named
Overrides</a>, this library provides the <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDE.html" title="Macro BOOST_CONTRACT_OVERRIDE">BOOST_CONTRACT_OVERRIDE</a></code>
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123869781472.html" title="Macro BOOST_CONTRACT_NAMED_OVERRIDE">BOOST_CONTRACT_NAMED_OVERRIDE</a></code>
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45394998912688.html" title="Macro BOOST_CONTRACT_NAMED_OVERRIDE">BOOST_CONTRACT_NAMED_OVERRIDE</a></code>
macros to program contracts for overriding public functions (see <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_MAX_ARGS.html" title="Macro BOOST_CONTRACT_MAX_ARGS">BOOST_CONTRACT_MAX_ARGS</a></code> for compilers
- that do not support variadic templates). <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f1" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f1"><sup class="footnote">[81]</sup></a> These macro cannot be programmed manually but they are not variadic
+ that do not support variadic templates). <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f1" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f1"><sup class="footnote">[82]</sup></a> These macro cannot be programmed manually but they are not variadic
macros (so programmers should be able to use them on any C++ compiler with
- a sound support for SFINAE). <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f2" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f2"><sup class="footnote">[8
2]</sup></a> The <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDES.html" title="Macro BOOST_CONTRACT_OVERRIDES">BOOST_CONTRACT_OVERRIDES</a></code>
+ a sound support for SFINAE). <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f2" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f2"><sup class="footnote">[8
3]</sup></a> The <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDES.html" title="Macro BOOST_CONTRACT_OVERRIDES">BOOST_CONTRACT_OVERRIDES</a></code>
macro is a variadic macro instead but programmes can manually repeat the
non-variadic macro <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDE.html" title="Macro BOOST_CONTRACT_OVERRIDE">BOOST_CONTRACT_OVERRIDE</a></code>
for each overriding public function name on compilers that do not support
etc. this library provides the <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_ASSERT.html" title="Macro BOOST_CONTRACT_ASSERT">BOOST_CONTRACT_ASSERT</a></code>
macro to assert contract conditions. This is not a variadic macro and programmers
should be able to use it on all C++ compilers. In any case, the invocation
- <code class="computeroutput"><span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span></code> expands
- to code equivalent to the following: <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f3" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f3"><sup class="footnote">[83]</sup></a>
+ <code class="computeroutput"><span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>cond</em></span></code><code class="computeroutput"><span class="special">)</span></code> simply expands to code equivalent to the
+ following: <a href="#ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f3" class="footnote" name="boost_contract.extras.no_macros__and_no_variadic_macros_.f3"><sup class="footnote">[84]</sup></a>
</p>
-<pre class="programlisting"><span class="keyword">if</span><span class="special">(!(</span><span class="identifier">cond</span><span class="special">))</span> <span class="special">{</span>
+<pre class="programlisting"><span class="keyword">if</span><span class="special">(!(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">))</span> <span class="special">{</span>
<span class="keyword">throw</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">assertion_failure</span><span class="special">(</span><span class="identifier">__FILE__</span><span class="special">,</span> <span class="identifier">__LINE__</span><span class="special">,</span>
- <span class="identifier">BOOST_PP_STRINGIZE</span><span class="special">(</span><span class="identifier">cond</span><span class="special">));</span>
+ <span class="identifier">BOOST_PP_STRINGIZE</span><span class="special">(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">));</span>
<span class="special">}</span>
</pre>
<p>
assertions that throw specific user-defined exceptions as follow (see <a class="link" href="advanced.html#boost_contract.advanced.throw_on_failures__and__noexcept__" title="Throw on Failures (and noexcept)">Throw
on Failures</a>):
</p>
-<pre class="programlisting"><span class="keyword">if</span><span class="special">(!</span><span class="identifier">cond</span><span class="special">)</span> <span class="keyword">throw</span> <span class="identifier">exception_object</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">if</span><span class="special">(!</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">)</span> <span class="keyword">throw</span> <code class="literal"><span class="emphasis"><em>exception-object</em></span></code><span class="special">;</span>
</pre>
<p>
However, using <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_ASSERT.html" title="Macro BOOST_CONTRACT_ASSERT">BOOST_CONTRACT_ASSERT</a></code>
name, line number, etc.
</p>
<p>
- The <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123871181520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
- and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45123897980656.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
- macros are not variadic macros and programmers should be able to use them
- on all C++ compilers. Their implementations are equivalent to the following:
+ As shown in <a class="link" href="extras.html#boost_contract.extras.assertion_levels" title="Assertion Levels">Assertion
+ Levels</a>, this library pre-defines <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395000817520.html" title="Macro BOOST_CONTRACT_ASSERT_AUDIT">BOOST_CONTRACT_ASSERT_AUDIT</a></code>
+ and <code class="computeroutput"><a class="link" href="../BOOST_CO_idm45395027441616.html" title="Macro BOOST_CONTRACT_ASSERT_AXIOM">BOOST_CONTRACT_ASSERT_AXIOM</a></code>
+ assertion levels. These macros are not variadic macros and programmers should
+ be able to use them on all C++ compilers. In any case, their implementations
+ are equivalent to the following:
</p>
<pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_CONTRACT_AUDITS</span>
- <span class="preprocessor">#define</span> <span class="identifier">BOOST_CONTRACT_ASSERT_AUDIT</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span> <span class="special">\</span>
- <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span>
+ <span class="preprocessor">#define</span> <span class="identifier">BOOST_CONTRACT_ASSERT_AUDIT</span><span class="special">(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">)</span> <span class="special">\</span>
+ <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">)</span>
<span class="preprocessor">#else</span>
- <span class="preprocessor">#define</span> <span class="identifier">BOOST_CONTRACT_ASSERT_AUDIT</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span> <span class="special">\</span>
- <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="keyword">true</span> <span class="special">||</span> <span class="special">(</span><span class="identifier">cond</span><span class="special">))</span>
+ <span class="preprocessor">#define</span> <span class="identifier">BOOST_CONTRACT_ASSERT_AUDIT</span><span class="special">(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">)</span> <span class="special">\</span>
+ <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="keyword">true</span> <span class="special">||</span> <span class="special">(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">))</span>
<span class="preprocessor">#endif</span>
-<span class="preprocessor">#define</span> <span class="identifier">BOOST_CONTRACT_ASSERT_AXIOM</span><span class="special">(</span><span class="identifier">cond</span><span class="special">)</span> <span class="special">\</span>
- <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="keyword">true</span> <span class="special">||</span> <span class="special">(</span><span class="identifier">cond</span><span class="special">))</span>
+<span class="preprocessor">#define</span> <span class="identifier">BOOST_CONTRACT_ASSERT_AXIOM</span><span class="special">(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">)</span> <span class="special">\</span>
+ <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="keyword">true</span> <span class="special">||</span> <span class="special">(</span><code class="literal"><span class="emphasis"><em>cond</em></span></code><span class="special">))</span>
</pre>
<h5>
<a name="boost_contract.extras.no_macros__and_no_variadic_macros_.h2"></a>
<p>
The ternary operator <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">copy_old</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span>
<span class="special">?</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">:</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">null_old</span><span class="special">()</span></code> must be used here to avoid evaluating and
- copying the old value expression <code class="computeroutput"><span class="identifier">size</span><span class="special">()</span></code> when <code class="computeroutput"><a class="link" href="../boost/contract/copy_old_idm45123869813440.html" title="Function copy_old">boost::contract::copy_old</a></code>
+ copying the old value expression <code class="computeroutput"><span class="identifier">size</span><span class="special">()</span></code> when <code class="computeroutput"><a class="link" href="../boost/contract/copy_old_idm45394998944672.html" title="Function copy_old">boost::contract::copy_old</a></code>
returns <code class="computeroutput"><span class="keyword">false</span></code> (because old values
- are not being copied when postcondition and exception guarantees checking
+ are not being copied when postcondition and exception guarantee checking
is disabled at run-time, an overridden virtual function call is not checking
- postconditions or exception guarantees yet, etc.). The enclosing <code class="computeroutput"><a class="link" href="../boost/contract/make_old_idm45123869837456.html" title="Function make_old">boost::contract::make_old</a></code>
+ postconditions or exception guarantees yet, etc.). The enclosing <code class="computeroutput"><a class="link" href="../boost/contract/make_old_idm45394998968720.html" title="Function make_old">boost::contract::make_old</a></code>
copies the old value expression and creates an old value pointer. Otherwise,
<code class="computeroutput"><a class="link" href="../boost/contract/null_old.html" title="Function null_old">boost::contract::null_old</a></code>
indicates that a null old value pointer should be created.
</p>
<p>
- The <code class="computeroutput"><a class="link" href="../boost/contract/make_old_idm45123869837456.html" title="Function make_old">boost::contract::make_old</a></code>
- and <code class="computeroutput"><a class="link" href="../boost/contract/copy_old_idm45123869813440.html" title="Function copy_old">boost::contract::copy_old</a></code>
+ The <code class="computeroutput"><a class="link" href="../boost/contract/make_old_idm45394998968720.html" title="Function make_old">boost::contract::make_old</a></code>
+ and <code class="computeroutput"><a class="link" href="../boost/contract/copy_old_idm45394998944672.html" title="Function copy_old">boost::contract::copy_old</a></code>
functions are used exactly as shown above but without the extra <code class="computeroutput"><span class="identifier">v</span></code> parameter when they are called from within
non-virtual functions (see <a class="link" href="tutorial.html#boost_contract.tutorial.public_function_overrides__subcontracting_" title="Public Function Overrides (Subcontracting)">Public
- Function Overrides</a>). The old value pointer returned by <code class="computeroutput"><a class="link" href="../boost/contract/make_old_idm45123869837456.html" title="Function make_old">boost::contract::make_old</a></code>
+ Function Overrides</a>). The old value pointer returned by <code class="computeroutput"><a class="link" href="../boost/contract/make_old_idm45394998968720.html" title="Function make_old">boost::contract::make_old</a></code>
can be assigned to either <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr.html" title="Class template old_ptr">boost::contract::old_ptr</a></code>
or <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>
(see <a class="link" href="extras.html#boost_contract.extras.old_value_requirements__templates_" title="Old Value Requirements (Templates)">Old
constructible. However, this library provides such a mechanism to allow
to program contracts for template code without necessarily adding extra
copy constructible type requirements that would not be present if it were
- not for copying the old values (so compiling the code with and without
- contracts will not necessarily alter the type requirements of the program).
- Something similar could be achieved combing C++17 <code class="computeroutput"><span class="keyword">if</span>
+ not for copying old values (so compiling the code with and without contracts
+ will not necessarily alter the type requirements of the program). Something
+ similar could be achieved combing C++17 <code class="computeroutput"><span class="keyword">if</span>
<span class="keyword">constexpr</span></code> with <a class="link" href="bibliography.html#N1962_anchor">[N1962]</a>
or <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a> so that old value expressions
- within template code could be guarded by <code class="computeroutput"><span class="keyword">if</span>
+ within template code can be guarded by <code class="computeroutput"><span class="keyword">if</span>
<span class="keyword">constexpr</span></code> statements checking if
the old value types are copyable or not. For example, assuming old values
- are added to <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a> (using the <code class="computeroutput"><span class="identifier">oldof</span><span class="special">(...)</span></code>
+ are added to <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a> (using some kind
+ of <code class="computeroutput"><span class="identifier">oldof</span><span class="special">(...)</span></code>
syntax) and that C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code> can be used within <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>
contracts:
</p>
<p>
</p>
</div>
+<div id="ftn.boost_contract.extras.old_value_requirements__templates_.f1" class="footnote">
+<p><a href="#boost_contract.extras.old_value_requirements__templates_.f1" class="para"><sup class="para">[69] </sup></a>
+ Technically, on C++17 it is possible to use <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr.html" title="Class template old_ptr">boost::contract::old_ptr</a></code>
+ together with <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
+ instead of using <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>,
+ for example:
+</p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
+<span class="keyword">void</span> <span class="identifier">offset</span><span class="special">(</span><span class="identifier">T</span><span class="special">&</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">count</span><span class="special">)</span> <span class="special">{</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">old_ptr</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span> <span class="identifier">old_x</span><span class="special">;</span>
+ <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">is_old_value_copyable</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="identifier">old_x</span> <span class="special">=</span> <span class="identifier">BOOST_CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">check</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">function</span><span class="special">()</span>
+ <span class="special">.</span><span class="identifier">postcondition</span><span class="special">([&]</span> <span class="special">{</span>
+ <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">is_old_value_copyable</span><span class="special"><</span><span class="identifier">T</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="identifier">BOOST_CONTRACT_ASSERT</span><span class="special">(</span><span class="identifier">x</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">old_x</span> <span class="special">+</span> <span class="identifier">count</span><span class="special">);</span>
+ <span class="special">})</span>
+ <span class="special">;</span>
+
+ <span class="identifier">x</span> <span class="special">+=</span> <span class="identifier">count</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+ However, the authors find this code less readable and more verbose than
+ its equivalent that uses <code class="computeroutput"><a class="link" href="../boost/contract/old_ptr_if_copyable.html" title="Class template old_ptr_if_copyable">boost::contract::old_ptr_if_copyable</a></code>.
+ Guarding old value copies and related assertions with <code class="computeroutput"><span class="keyword">if</span>
+ <span class="keyword">constexpr</span></code> is useful instead when
+ the guard condition checks type requirements more complex than just <code class="computeroutput"><a class="link" href="../boost/contract/is_old_value_copyable.html" title="Struct template is_old_value_copyable">boost::contract::is_old_value_copyable</a></code>
+ (as shown later in this documentation).
+ </p>
+</div>
<div id="ftn.boost_contract.extras.assertion_requirements__templates_.f0" class="footnote">
-<p><a href="#boost_contract.extras.assertion_requirements__templates_.f0" class="para"><sup class="para">[69] </sup></a>
+<p><a href="#boost_contract.extras.assertion_requirements__templates_.f0" class="para"><sup class="para">[70] </sup></a>
<span class="bold"><strong>Rationale:</strong></span> <a class="link" href="bibliography.html#N1962_anchor">[N1962]</a>
and other proposals to add contracts to C++ do not provide a mechanism
to selectively disable assertions based on their type requirements. However,
this library provides such a mechanism to allow to program contracts for
template code without necessarily adding extra type requirements that would
not be present if it was not for the contracts (so compiling the code with
- and without contracts will not necessarily alter the type requirements
- of the program). Something similar could be achieved combing C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
- with <a class="link" href="bibliography.html#N1962_anchor">[N1962]</a> or <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>
- so that contract assertions within template code could be guarded by <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
- statements checking related type requirements (<a class="link" href="bibliography.html#N1962_anchor">[N1962]</a>
- already supports <code class="computeroutput"><span class="keyword">if</span></code> statements
- under the name of <span class="emphasis"><em>select assertions</em></span>, <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>
- does not so probably <code class="computeroutput"><span class="keyword">if</span></code> statements
- should be added to <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a> as well).
- For example, assuming old values are added to <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>
- (using the <code class="computeroutput"><span class="identifier">oldof</span><span class="special">(...)</span></code>
- syntax) and that C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code> can be used within <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>
- contracts:
+ and without contracts will not alter the type requirements of the program).
+ Something similar could be achieved combing C++17 <code class="computeroutput"><span class="keyword">if</span>
+ <span class="keyword">constexpr</span></code> with <a class="link" href="bibliography.html#N1962_anchor">[N1962]</a>
+ or <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a> so that contract assertions
+ within template code could be guarded by <code class="computeroutput"><span class="keyword">if</span>
+ <span class="keyword">constexpr</span></code> statements checking the
+ related type requirements (<a class="link" href="bibliography.html#N1962_anchor">[N1962]</a>
+ already allows of <code class="computeroutput"><span class="keyword">if</span></code> statements
+ in contracts under the name of <span class="emphasis"><em>select assertions</em></span>,
+ <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a> does not so probably <code class="computeroutput"><span class="keyword">if</span></code> statements should be added to <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>
+ as well). For example, assuming C++17 <code class="computeroutput"><span class="keyword">if</span>
+ <span class="keyword">constexpr</span></code> can be used within <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a> contracts:
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">class</span> <span class="identifier">vector</span> <span class="special">{</span>
<p>
</p>
</div>
-<div id="ftn.boost_contract.extras.assertion_requirements__templates_.f1" class="footnote"><p><a href="#boost_contract.extras.assertion_requirements__templates_.f1" class="para"><sup class="para">[70] </sup></a>
-
For optimization reasons, the internal implementation of <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
- does not actually use <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>.
+<div id="ftn.boost_contract.extras.assertion_requirements__templates_.f1" class="footnote"><p><a href="#boost_contract.extras.assertion_requirements__templates_.f1" class="para"><sup class="para">[71] </sup></a>
+
The internal implementation of <code class="computeroutput"><a class="link" href="../boost/contract/condition_if.html" title="Function template condition_if">boost::contract::condition_if</a></code>
+
is optimized and it does not actually use <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>.
</p></div>
-<div id="ftn.boost_contract.extras.assertion_requirements__templates_.f2" class="footnote"><p><a href="#boost_contract.extras.assertion_requirements__templates_.f2" class="para"><sup class="para">[71] </sup></a>
- Boost.Hana (<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">hana</span><span class="special">::</span><span class="identifier">if_</span></code>) and probably other approaches can
- also be used together with generic lambdas to emulate C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
- on C++14 compilers.
- </p></div>
-<div id="ftn.boost_contract.extras.volatile_public_functions.f0" class="footnote"><p><a href="#boost_contract.extras.volatile_public_functions.f0" class="para"><sup class="para">[72] </sup></a>
+<div id="ftn.boost_contract.extras.assertion_requirements__templates_.f2" class="footnote">
+<p><a href="#boost_contract.extras.assertion_requirements__templates_.f2" class="para"><sup class="para">[72] </sup></a>
+ </p>
+<p>
+ A part from its use within contracts, <code class="computeroutput"><a class="link" href="../boost/contract/call_if.html" title="Function template call_if">boost::contract::call_if</a></code>
+ can be used together with C++14 generic lambdas to emulate C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
+ (<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">hana</span><span class="special">::</span><span class="identifier">if_</span></code> and probably other approaches can
+ also be used together with generic lambdas to emulate C++17 <code class="computeroutput"><span class="keyword">if</span> <span class="keyword">constexpr</span></code>
+ on C++14 compilers). For example, the following implementation of <code class="computeroutput"><span class="identifier">myadvance</span></code> will compile since C++14
+ and it is more concise, easier to read and maintain than the usual implementation
+ of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">advance</span></code> that uses tag dispatching (see
+ <a href="../../../example/features/call_if_cxx14.cpp" target="_top"><code class="literal">call_if_cxx14.cpp</code></a>):
+ </p>
+<p>
+ </p>
+<p>
+</p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Iter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Dist</span><span class="special">></span>
+<span class="keyword">void</span> <span class="identifier">myadvance</span><span class="special">(</span><span class="identifier">Iter</span><span class="special">&</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">Dist</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
+ <span class="identifier">Iter</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="special">&</span><span class="identifier">i</span><span class="special">;</span> <span class="comment">// So captures change actual pointed iterator value.</span>
+ <span class="identifier">boost</span><span class="special">::</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">call_if</span><span class="special"><</span><span class="identifier">is_random_access_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">></span> <span class="special">>(</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">auto</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> <span class="comment">// C++14 generic lambda.</span>
+ <span class="special">*</span><span class="identifier">p</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
+ <span class="special">},</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span>
+ <span class="special">).</span><span class="keyword">template</span> <span class="identifier">else_if</span><span class="special"><</span><span class="identifier">is_bidirectional_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">></span> <span class="special">>(</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">auto</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">if</span><span class="special">(</span><span class="identifier">n</span> <span class="special">>=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++*</span><span class="identifier">p</span><span class="special">;</span>
+ <span class="keyword">else</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">++)</span> <span class="special">--*</span><span class="identifier">p</span><span class="special">;</span>
+ <span class="special">},</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span>
+ <span class="special">).</span><span class="keyword">template</span> <span class="identifier">else_if</span><span class="special"><</span><span class="identifier">is_input_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">></span> <span class="special">>(</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">p</span><span class="special">,</span> <span class="keyword">auto</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++*</span><span class="identifier">p</span><span class="special">;</span>
+ <span class="special">},</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span>
+ <span class="special">).</span><span class="identifier">else_</span><span class="special">(</span>
+ <span class="identifier">std</span><span class="special">::</span><span class="identifier">bind</span><span class="special">([]</span> <span class="special">(</span><span class="keyword">auto</span> <span class="identifier">false_</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">false_</span><span class="special">,</span> <span class="string">"requires at least input iterator"</span><span class="special">);</span>
+ <span class="special">},</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">false_type</span><span class="special">())</span> <span class="comment">// Use constexpr value.</span>
+ <span class="special">);</span>
+<span class="special">}</span>
+</pre>
+<p>
+ </p>
+<p>
+ </p>
+<p>
+ Of course, since C++17 the implementation that uses <code class="computeroutput"><span class="keyword">if</span>
+ <span class="keyword">constexpr</span></code> is even more readable
+ and concise:
+</p>
+<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Iter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Dist</span><span class="special">></span>
+<span class="keyword">void</span> <span class="identifier">myadvance</span><span class="special">(</span><span class="identifier">Iter</span><span class="special">&</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">Dist</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">is_random_access_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
+ <span class="identifier">i</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
+ <span class="special">}</span> <span class="keyword">else</span> <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">is_bidirectional_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">if</span><span class="special">(</span><span class="identifier">n</span> <span class="special">>=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++</span><span class="identifier">i</span><span class="special">;</span>
+ <span class="keyword">else</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">++)</span> <span class="special">--</span><span class="identifier">i</span><span class="special">;</span>
+ <span class="special">}</span> <span class="keyword">else</span> <span class="keyword">if</span> <span class="keyword">constexpr</span><span class="special">(</span><span class="identifier">is_input_iterator</span><span class="special"><</span><span class="identifier">Iter</span><span class="special">>::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">{</span>
+ <span class="keyword">while</span><span class="special">(</span><span class="identifier">n</span><span class="special">--)</span> <span class="special">++</span><span class="identifier">i</span><span class="special">;</span>
+ <span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
+ <span class="keyword">static_assert</span><span class="special">(</span><span class="keyword">false</span><span class="special">,</span> <span class="string">"requires at least input iterator"</span><span class="special">);</span>
+ <span class="special">}</span>
+<span class="special">}</span>
+</pre>
+<p>
+ </p>
+<p>
+ </p>
+</div>
+<div id="ftn.boost_contract.extras.volatile_public_functions.f0" class="footnote"><p><a href="#boost_contract.extras.volatile_public_functions.f0" class="para"><sup class="para">[73] </sup></a>
<span class="bold"><strong>Rationale:</strong></span> Constructors and destructors
check <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code>
and <code class="computeroutput"><span class="keyword">const</span></code> invariants in that
more calls than <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code>,
in fact an object is not even needed to make static calls).
</p></div>
-<div id="ftn.boost_contract.extras.volatile_public_functions.f1" class="footnote"><p><a href="#boost_contract.extras.volatile_public_functions.f1" class="para"><sup class="para">[73] </sup></a>
+<div id="ftn.boost_contract.extras.volatile_public_functions.f1" class="footnote"><p><a href="#boost_contract.extras.volatile_public_functions.f1" class="para"><sup class="para">[74] </sup></a>
<span class="bold"><strong>Rationale:</strong></span> Note that while all public
functions can be made to check <code class="computeroutput"><span class="keyword">const</span>
<span class="keyword">volatile</span></code> invariants, it is never
<span class="keyword">volatile</span></code> invariants and only non-volatile
public functions check <code class="computeroutput"><span class="keyword">const</span></code>
(but not <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code>)
- invariants. This is simple and should serve most cases. If programmers
- need non-volatile public functions to also check <code class="computeroutput"><span class="keyword">const</span>
- <span class="keyword">volatile</span></code> invariants, they can explicitly
- do so by calling the <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code> invariant function from the <code class="computeroutput"><span class="keyword">const</span></code> invariant function as shown in this
- documentation.
+ invariants. This is a clear distinction and it should serve most cases.
+ If programmers need non-volatile public functions to also check <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code>
+ invariants, they can explicitly do so by calling the <code class="computeroutput"><span class="keyword">const</span>
+ <span class="keyword">volatile</span></code> invariant function from
+ the <code class="computeroutput"><span class="keyword">const</span></code> invariant function
+ as shown in this documentation.
</p></div>
-<div id="ftn.boost_contract.extras.move_operations.f0" class="footnote"><p><a href="#boost_contract.extras.move_operations.f0" class="para"><sup class="para">[74] </sup></a>
+<div id="ftn.boost_contract.extras.move_operations.f0" class="footnote"><p><a href="#boost_contract.extras.move_operations.f0" class="para"><sup class="para">[75] </sup></a>
In this example, the <code class="computeroutput"><span class="identifier">moved</span><span class="special">()</span></code> function is simple enough that programmers
- could decide to not even call <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45123869756752.html" title="Function template public_function">boost::contract::public_function</a></code>
- from it. However, calling <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45123869756752.html" title="Function template public_function">boost::contract::public_function</a></code>
+ could decide to not even call <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45394998885120.html" title="Function template public_function">boost::contract::public_function</a></code>
+ from it for optimization reasons. However, calling <code class="computeroutput"><a class="link" href="../boost/contract/public_f_idm45394998885120.html" title="Function template public_function">boost::contract::public_function</a></code>
from <code class="computeroutput"><span class="identifier">moved</span><span class="special">()</span></code>
- has no negative impact a part from run-time overhead because this library
- already automatically disables contract checking while checking other contracts
+ has no negative impact, a part from run-time overhead, because this library
+ automatically disables contract checking while checking other contracts
(so this call will not cause infinite recursion).
</p></div>
-<div id="ftn.boost_contract.extras.assertion_levels.f0" class="footnote"><p><a href="#boost_contract.extras.assertion_levels.f0" class="para"><sup class="para">[75] </sup></a>
+<div id="ftn.boost_contract.extras.assertion_levels.f0" class="footnote"><p><a href="#boost_contract.extras.assertion_levels.f0" class="para"><sup class="para">[76] </sup></a>
The assertion levels predefined by this library are similar to the default,
- audit, and axiom levels
proposed in <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>.
+ audit, and axiom levels
from <a class="link" href="bibliography.html#P0380_anchor">[P0380]</a>.
</p></div>
<div id="ftn.boost_contract.extras.separate_body_implementation.f0" class="footnote">
-<p><a href="#boost_contract.extras.separate_body_implementation.f0" class="para"><sup class="para">[76] </sup></a>
+<p><a href="#boost_contract.extras.separate_body_implementation.f0" class="para"><sup class="para">[77] </sup></a>
When used as default parameter values, lambda functions allow to program
code statements within function declarations. However, these lambadas cannot
- be effectively used to program contracts because the C++11 standard does
- not allow them to capture any variable (it would be not at all obvious
- how to correctly define the semantics of such captures). For example, the
- following code does not compile:
+ be effectively used to program contracts in function declarations instead
+ of definitions. That is because the C++11 standard does not allow lambdas
+ in function declarations to capture any variable (for the good reason that
+ it is not at all obvious how to correctly define the semantics of such
+ captures). For example, the following code is not valid C++ and it does
+ not compile:
</p>
<pre class="programlisting"><span class="comment">// Specifications (in declaration).</span>
<span class="keyword">int</span> <span class="identifier">inc</span><span class="special">(</span><span class="keyword">int</span><span class="special">&</span> <span class="identifier">x</span><span class="special">,</span>
boiler-plate code to bind return and old values.
</p>
</div>
-<div id="ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f0" class="footnote"><p><a href="#boost_contract.extras.no_lambda_functions__no_c__11_.f0" class="para"><sup class="para">[77] </sup></a>
+<div id="ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f0" class="footnote"><p><a href="#boost_contract.extras.no_lambda_functions__no_c__11_.f0" class="para"><sup class="para">[78] </sup></a>
+ Alternatively, on compilers that do not support C++11 lambda functions,
+ <a href="http://www.boost.org/doc/libs/release/libs/local_function/doc/html/index.html" target="_top">Boost.LocalFunction</a>
+ could be used to program the contract functors still within the function
+ definitions (for example, see <a href="../../../example/features/no_lambdas_local_func.cpp" target="_top"><code class="literal">no_lambda_local_func.cpp</code></a>).
+ In general, such a code is less verbose than the example shown in this
+ section that uses contract functions programmed outside of the original
+ function definitions (about 30% less lines of code) but the contract
+ code is hard to read. Other libraries could also be used to program
+ the contract functors without C++11 lambda functions (Boost.Lambda,
+ Boost.Fusion, etc.) but again all these techniques will result in contract
+ code either more verbose, or harder to read and maintain than the code
+ that uses C++11 lambda functions.
+ </p></div>
+<div id="ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f1" class="footnote"><p><a href="#boost_contract.extras.no_lambda_functions__no_c__11_.f1" class="para"><sup class="para">[79] </sup></a>
If C++ allowed lambda functions to capture variables by constant reference
- (for example using the syntax <code class="computeroutput"><span class="special">[</span><span class="keyword">const</span><span class="special">&]</span>
+ (for example allowing a syntax like this <code class="computeroutput"><span class="special">[</span><span class="keyword">const</span><span class="special">&]</span>
<span class="special">{</span> <span class="special">...</span>
<span class="special">}</span></code> and <code class="computeroutput"><span class="special">[</span><span class="keyword">const</span><span class="special">&</span>
</code><code class="literal"><span class="emphasis"><em>variable-name</em></span></code><code class="computeroutput"><span class="special">]</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>,
at compile-time. Note that C++11 lambdas allow to capture variables
by value (using <code class="computeroutput"><span class="special">[=]</span> <span class="special">{</span>
<span class="special">...</span> <span class="special">}</span></code>
- and <code class="computeroutput"><span class="special">[</span></code><code class="literal"><span class="emphasis"><em>variable-name</em></span></code><code class="computeroutput"><span class="special">]</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>),
- these value captures are <code class="computeroutput"><span class="keyword">const</span></code>
+ and <code class="computeroutput"><span class="special">[</span></code><code class="literal"><span class="emphasis"><em>variable-name</em></span></code><code class="computeroutput"><span class="special">]</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>)
+ and these value captures are <code class="computeroutput"><span class="keyword">const</span></code>
(unless the lambda is explicitly declared <code class="computeroutput"><span class="keyword">mutable</span></code>)
but they are not suitable to program postconditions and exception guarantees
using this library (because those require capturing by reference, see
that might be too expensive in general and therefore not suitable for
preconditions either.
</p></div>
-<div id="ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f1" class="footnote"><p><a href="#boost_contract.extras.no_lambda_functions__no_c__11_.f1" class="para"><sup class="para">[78] </sup></a>
- Alternatively, on compilers that do not support C++11 lambda functions,
- <a href="http://www.boost.org/doc/libs/release/libs/local_function/doc/html/index.html" target="_top">Boost.LocalFunction</a>
- could be used to program the contract functors still within the function
- definitions (for example, see <a href="../../../example/features/no_lambdas_local_func.cpp" target="_top"><code class="literal">no_lambda_local_func.cpp</code></a>).
- In general, such a code is less verbose than the example shown in this
- section that uses contract functions programmed outside of the original
- function definitions (about 30% less lines of code) but the contract
- code is hard to read. Other libraries could also be used to program
- the contract functors without C++11 lambda functions (Boost.Lambda,
- Boost.Fusion, etc.) but again all these techniques will result in contract
- code either more verbose, or harder to read and maintain than the code
- that uses C++11 lambda functions.
- </p></div>
-<div id="ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f2" class="footnote"><p><a href="#boost_contract.extras.no_lambda_functions__no_c__11_.f2" class="para"><sup class="para">[79] </sup></a>
+<div id="ftn.boost_contract.extras.no_lambda_functions__no_c__11_.f2" class="footnote"><p><a href="#boost_contract.extras.no_lambda_functions__no_c__11_.f2" class="para"><sup class="para">[80] </sup></a>
In this example, <code class="computeroutput"><span class="identifier">bind</span></code> was
used to generate nullary functors from the contract functions. As always
with <code class="computeroutput"><span class="identifier">bind</span></code>, <code class="computeroutput"><span class="identifier">cref</span></code> and <code class="computeroutput"><span class="identifier">ref</span></code>
the function pointer passed to <code class="computeroutput"><span class="identifier">bind</span></code>
for overloaded functions.
</p></div>
-<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f0" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f0" class="para"><sup class="para">[80] </sup></a>
+<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f0" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f0" class="para"><sup class="para">[81] </sup></a>
Compilation times of this library were measured to be comparable between
compilers that support variadic macros and compilers that do not.
</p></div>
-<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f1" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f1" class="para"><sup class="para">[81] </sup></a>
+<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f1" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f1" class="para"><sup class="para">[82] </sup></a>
<span class="bold"><strong>Rationale:</strong></span> The <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_MAX_ARGS.html" title="Macro BOOST_CONTRACT_MAX_ARGS">BOOST_CONTRACT_MAX_ARGS</a></code>
macro is named after <code class="computeroutput"><span class="identifier">BOOST_FUNCTION_MAX_ARGS</span></code>.
</p></div>
-<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f2" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f2" class="para"><sup class="para">[82] </sup></a>
- <span class="bold"><strong>Rationale:</strong></span> These macros expand SFINAE-based
- introspection templates that are too complex to be programmed manually
+<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f2" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f2" class="para"><sup class="para">[83] </sup></a>
+ <span class="bold"><strong>Rationale:</strong></span> These macros expand to SFINAE-based
+ introspection template code that are too complex to be programmed manually
by users (that remains the case even if C++14 generic lambdas were to be
used here). On a related note, in theory using C++14 generic lambdas, the
<code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_OVERRIDE.html" title="Macro BOOST_CONTRACT_OVERRIDE">BOOST_CONTRACT_OVERRIDE</a></code>
macro could be re-implemented in a way that can be expanded at function
scope, instead of class scope (but there is not really a need to do that).
</p></div>
-<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f3" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f3" class="para"><sup class="para">[83] </sup></a>
+<div id="ftn.boost_contract.extras.no_macros__and_no_variadic_macros_.f3" class="footnote"><p><a href="#boost_contract.extras.no_macros__and_no_variadic_macros_.f3" class="para"><sup class="para">[84] </sup></a>
<span class="bold"><strong>Rationale:</strong></span> There is no need for the code
expanded by <code class="computeroutput"><a class="link" href="../BOOST_CONTRACT_ASSERT.html" title="Macro BOOST_CONTRACT_ASSERT">BOOST_CONTRACT_ASSERT</a></code>
to also use C++11 <code class="computeroutput"><span class="identifier">__func__</span></code>.
That is because <code class="computeroutput"><span class="identifier">__func__</span></code>
- will always expand to the name of <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> of the functor used to program the contract
- assertions (e.g., of the lambda function) and it will not expand to the
- name of the actual function specifying the contract.
+ will always expand to the name <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> of the functor used to program the contract
+ assertions (e.g., the internal name the compiler assigns to lambda functions)
+ and it will not expand to the name of the actual function enclosing the
+ contract declaration.
</p></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright © 2008-201
8 Lorenzo Caminiti<p>
+<td align="right"><div class="copyright-footer">Copyright © 2008-201
9 Lorenzo Caminiti<p>
Distributed under the Boost Software License, Version 1.0 (see accompanying
file LICENSE_1_0.txt or a copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
projects / platform / upstream / boost.git / blobdiff