boost/contract
2
0
Fork 0
mirror of https://github.com/boostorg/contract.git synced 2026-01-24 17:52:41 +00:00
Code Issues Projects Releases Wiki Activity
Files
v0.4.0
contract/doc/html/contractpp.html
Lorenzo Caminiti 4061f372f3 added all files for release 0.4.0
2017-08-28 19:49:35 -07:00

14237 lines
1.9 MiB
Executable File
Raw Permalink Blame History

<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Contract++ 0.4.0</title><link rel="stylesheet" type="text/css" href="../../doc/src/boostbook.css"><meta name="generator" content="DocBook XSL Stylesheets V1.76.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="preface" title="Contract++ 0.4.0"><div class="titlepage"><div><div><h2 class="title"><a name="contract__"></a>Contract++ 0.4.0</h2></div><div><div class="authorgroup"><div class="author"><h3 class="author"><span class="firstname">Lorenzo</span> <span class="surname">Caminiti <code class="email">&lt;<a class="email" href="mailto:lorcaminiti@gmail.com">lorcaminiti@gmail.com</a>&gt;</code></span></h3></div></div></div><div><p class="copyright">Copyright © 2008-2012 Lorenzo Caminiti</p></div><div><div class="legalnotice" title="Legal Notice"><a name="contract__.legal"></a><p>
Distributed under the Boost Software License, Version 1.0 (see accompanying
file LICENSE_1_0.txt or a copy at <a class="ulink" href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></div></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#contract__.introduction">Introduction</a></span></dt><dt><span class="section"><a href="#contract__.full_table_of_contents">Full Table of Contents</a></span></dt><dt><span class="section"><a href="#contract__.getting_started">Getting Started</a></span></dt><dt><span class="section"><a href="#contract__.contract_programming_overview">Contract Programming
Overview</a></span></dt><dt><span class="section"><a href="#contract__.tutorial">Tutorial</a></span></dt><dt><span class="section"><a href="#contract__.advanced_topics">Advanced Topics</a></span></dt><dt><span class="section"><a href="#contract__.virtual_specifiers">Virtual Specifiers</a></span></dt><dt><span class="section"><a href="#contract__.concepts">Concepts</a></span></dt><dt><span class="section"><a href="#contract__.named_parameters">Named Parameters</a></span></dt><dt><span class="section"><a href="#contract__.examples">Examples</a></span></dt><dt><span class="section"><a href="#contract__.grammar">Grammar</a></span></dt><dt><span class="section"><a href="#contract__.no_variadic_macros">No Variadic Macros</a></span></dt><dt><span class="section"><a href="#reference">Reference</a></span></dt><dt><span class="section"><a href="#contract__.release_notes">Release Notes</a></span></dt><dt><span class="section"><a href="#contract__.bibliography">Bibliography</a></span></dt><dt><span class="section"><a href="#contract__.acknowledgments">Acknowledgments</a></span></dt></dl></div><div class="blockquote"><blockquote class="blockquote"><p>
<span class="emphasis"><em><span class="quote">&#8220;<span class="quote">Our field needs more formality, but the profession has not
realized it yet.</span>&#8221;</span></em></span>
</p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
<span class="emphasis"><em>--Meyer (see <a class="link" href="#Meyer97_anchor">[Meyer97]</a> page
400)</em></span>
</p></blockquote></div><p>
This library implements Contract Programming for the C++ programming language.
In addition, the library implements virtual specifiers (<code class="computeroutput"><span class="identifier">final</span></code>,
<code class="computeroutput"><span class="identifier">override</span></code>, and <code class="computeroutput"><span class="keyword">new</span></code>,
see <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>), concept
checking, and named parameters.
</p><p>
Consult this documentation on a <a class="ulink" href="contractpp.html" target="_top">single page</a>
or on <a class="ulink" href="index.html" target="_top">multiple pages</a>.
</p><div class="section" title="Introduction"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.introduction"></a><a class="link" href="#contract__.introduction" title="Introduction">Introduction</a></h2></div></div></div><p>
<a class="ulink" href="http://en.wikipedia.org/wiki/Design_by_contract" target="_top">Contract Programming</a>
(CP) allows to specify preconditions, postconditions, and class invariants
that are automatically checked when functions are executed at run-time. These
conditions assert program specifications within the source code itself allowing
to find bugs more quickly during testing, making the code self-documenting,
and increasing overall software quality.
</p><p>
Contract Programming is also known as Design by Contract (DbC) <sup>[<a name="contract__.introduction.f0" href="#ftn.contract__.introduction.f0" class="footnote">1</a>]</sup> and it was first introduced by the <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
programming language (see <a class="link" href="#Meyer97_anchor">[Meyer97]</a>).
All Contract Programming features of the <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
programming language are supported by this library, among others (see also
the <a class="link" href="#contract__.contract_programming_overview.features" title="Features">Features</a>
section):
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Support for preconditions, postconditions, class invariants, block invariants,
and loop variants.
</li><li class="listitem">
Subcontract derived classes (with support for pure virtual functions and
multiple inheritance).
</li><li class="listitem">
Access expression old values and function return value in postconditions.
</li><li class="listitem">
Optional compilation and checking of preconditions, postconditions, class
invariants, block invariants, and loop variants.
</li><li class="listitem">
Customizable actions on contract assertion failure (terminate by default
but it can throw, exit, etc).
</li></ol></div><p>
In addition, this library supports virtual specifiers, concept checking, and
named parameters which together with contracts specify requirements of the
program interface. This library is implemented for the <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
standard and it does not require <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>.
</p><h4><a name="contract__.introduction.h0"></a>
<span><a name="contract__.introduction.an_example"></a></span><a class="link" href="#contract__.introduction.an_example">An
Example</a>
</h4><p>
The example below shows how to use this library to program contracts for the
C++ Standard Template Library (STL) member function <a class="ulink" href="http://www.sgi.com/tech/stl/BackInsertionSequence.html" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">::</span><span class="identifier">push_back</span></code></a>
(in order to illustrate subcontracting, the <code class="computeroutput"><span class="identifier">vector</span></code>
class inherits from the somewhat arbitrary <code class="computeroutput"><span class="identifier">pushable</span></code>
base class). The syntax used by this library is compared side-by-side with
the syntax proposed by <a class="link" href="#N1962_anchor">[N1962]</a> for adding
Contract Programming to C++ (see also <a class="ulink" href="../../example/contracts/push_back.cpp" target="_top"><code class="literal">push_back.cpp</code></a>
and <a class="ulink" href="../../example/contracts/pushable.hpp" target="_top"><code class="literal">pushable.hpp</code></a>):
</p><div class="informaltable"><table border="1"><colgroup><col><col><col></colgroup><thead><tr><th>
<p>
#
</p>
</th><th>
<p>
This Library (C++03)
</p>
</th><th>
<p>
N1962 and N2081 Proposals (not adopted by C++11) <sup>[<a name="contract__.introduction.f1" href="#ftn.contract__.introduction.f1" class="footnote">a</a>]</sup>
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"> <span class="number">1</span>
<span class="number">2</span>
<span class="number">3</span>
<span class="number">4</span>
<span class="number">5</span>
<span class="number">6</span>
<span class="number">7</span>
<span class="number">8</span>
<span class="number">9</span>
<span class="number">10</span>
<span class="number">11</span>
<span class="number">12</span>
<span class="number">13</span>
<span class="number">14</span>
<span class="number">15</span>
<span class="number">16</span>
<span class="number">17</span>
<span class="number">18</span>
<span class="number">19</span>
<span class="number">20</span>
<span class="number">21</span>
<span class="number">22</span>
<span class="number">23</span>
<span class="number">24</span>
<span class="number">25</span>
<span class="number">26</span>
<span class="number">27</span>
<span class="number">28</span>
<span class="number">29</span>
<span class="number">30</span>
<span class="number">31</span>
<span class="number">32</span>
<span class="number">33</span>
<span class="number">34</span>
<span class="number">35</span>
<span class="number">36</span>
<span class="number">37</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// This library.</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="string">"pushable.hpp"</span> <span class="comment">// Some base class.</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">CopyConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span> <span class="comment">// Concepts.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span> <span class="comment">// Subcontracting.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="comment">// More class invariants here...</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span> <span class="identifier">override</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="comment">// More preconditions here...</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span> <span class="comment">// Old-of values.</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span> <span class="comment">// More postconditions here...</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</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="comment">// Original function body.</span>
<span class="special">}</span>
<span class="comment">// Rest of class here (possibly with more contracts)...</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">bool</span> <span class="identifier">empty</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">size_type</span> <span class="identifier">size</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">size_type</span> <span class="identifier">max_size</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">max_size</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reference</span> <span class="identifier">back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">vector_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="comment">// Extra spaces, newlines, etc used to align text with this library code.</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">concept</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="string">"pushable.hpp"</span> <span class="comment">// Some base class.</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="identifier">requires</span> <span class="identifier">CopyConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="comment">// Concepts.</span>
<span class="keyword">class</span> <span class="identifier">vector</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="comment">// Subcontracting.</span>
<span class="special">{</span>
<span class="identifier">invariant</span> <span class="special">{</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span> <span class="comment">// More class invariants here...</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</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">&amp;</span> <span class="identifier">value</span> <span class="special">)</span> <span class="identifier">override</span>
<span class="identifier">precondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">();</span> <span class="comment">// More preconditions here...</span>
<span class="special">}</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="comment">// Old-of values use `oldof` operator.</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="number">1</span><span class="special">;</span> <span class="comment">// More postconditions here...</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</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="comment">// Original function body.</span>
<span class="special">}</span>
<span class="comment">// Rest of class here (with possibly more contracts)...</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">bool</span> <span class="identifier">empty</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">size_type</span> <span class="identifier">size</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">size_type</span> <span class="identifier">max_size</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">max_size</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reference</span> <span class="identifier">back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">vector_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p>
</td></tr></tbody><tbody class="footnotes"><tr><td colspan="3"><div class="footnote"><p><sup>[<a id="ftn.contract__.introduction.f1" href="#contract__.introduction.f1" class="para">a</a>] </sup>
Unfortunately, the Contract Programming proposal <a class="link" href="#N1962_anchor">[N1962]</a>
and the concept proposal <a class="link" href="#N2081_anchor">[N2081]</a>
were never adopted by the C++ standard so the example on the right
hand side will not compile.
</p></div></td></tr></tbody></table></div><p>
Classes and functions are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macros
respectively. Class invariants must appear at the very beginning of the class
definition and they are specified using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code>
macro. The <code class="computeroutput"><span class="identifier">TPL</span></code> postfixes indicate
versions of the macros that need to be used within templates.
</p><p>
Note the following differences between the syntax used by this library macros
and the usual C++ declaration syntax (see the <a class="link" href="#contract__.grammar.differences_with_c___syntax" title="Differences with C++ Syntax">Differences
with C++ Syntax</a> section for a complete list):
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Round parenthesis <code class="computeroutput"><span class="keyword">template</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span></code>
are used instead of angular parenthesis <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span> <span class="special">...</span> <span class="special">&gt;</span></code> to declare templates (line 7).
</li><li class="listitem">
Similarly to <a class="link" href="#N2081_anchor">[N2081]</a>, the specifier
<code class="computeroutput"><span class="identifier">requires</span><span class="special">(</span>
<span class="special">...</span> <span class="special">)</span></code>
is used to specify concepts to check (line 7).
</li><li class="listitem">
The class and function names are wrapped within round parenthesis <code class="computeroutput"><span class="special">(</span><span class="identifier">vector</span><span class="special">)</span></code> and <code class="computeroutput"><span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span></code>
(lines 8 and 18).
</li><li class="listitem">
The specifier <code class="computeroutput"><span class="identifier">extends</span><span class="special">(</span>
<span class="special">...</span> <span class="special">)</span></code>
is used instead of the column symbol <code class="computeroutput"><span class="special">:</span></code>
to inherit from base classes (line 8). This automatically subcontracts
<code class="computeroutput"><span class="identifier">vector</span></code> from <code class="computeroutput"><span class="identifier">pushable</span></code> (when subcontracting, derived
and base preconditions are checked in <a class="link" href="#logic_or_anchor">logic-or</a>,
derived and base postconditions are checked in <a class="link" href="#logic_and_anchor">logic-and</a>,
derived and base class invariants are checked <a class="link" href="#logic_and_anchor">logic-and</a>).
</li><li class="listitem">
The access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> must always be specified for member
functions but without the trailing column symbol <code class="computeroutput"><span class="special">:</span></code>
(line 18).
</li><li class="listitem">
The function result and parameter types are wrapped within round parenthesis
<code class="computeroutput"><span class="special">(</span><span class="identifier">T</span>
<span class="keyword">const</span><span class="special">&amp;)</span></code>
(line 18). The parenthesis are allowed but not required for fundamental
types that contain no symbol (e.g., the function result type <code class="computeroutput"><span class="keyword">void</span></code> at line 18, but also <code class="computeroutput"><span class="keyword">bool</span></code>, <code class="computeroutput"><span class="keyword">unsigned</span>
<span class="keyword">int</span> <span class="keyword">const</span></code>,
etc).
</li><li class="listitem">
Similarly to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>,
the specifier <code class="computeroutput"><span class="identifier">override</span></code>
is used to check that a member function is indeed overriding a base member
function (line 18).
</li><li class="listitem">
The specifiers <code class="computeroutput"><span class="identifier">precondition</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span></code>
and <code class="computeroutput"><span class="identifier">postcondition</span><span class="special">(</span>
<span class="special">...</span> <span class="special">)</span></code>
are used to program function preconditions and postconditions (lines 19
and 22). Furthermore, the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code>
macro can be used within postconditions to declare variables and initialize
them to old values that the specified expressions had before executing
the function body (line 23).
</li><li class="listitem">
Class invariants, preconditions, and postconditions assert boolean expressions
separated by commas <code class="computeroutput"><span class="special">,</span></code> (lines
11, 20, and 24).
</li></ul></div><p>
Finally, note that the class and function definitions are programmed outside
the macros so they retain their usual C++ syntax (e.g., the function body at
line 27).
</p><p>
The library executes the following steps when the <code class="computeroutput"><span class="identifier">push_back</span></code>
function is called at run-time (see also the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract
Programming Overview</a> section):
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
First, the class invariants and the function preconditions are checked.
</li><li class="listitem">
Then, the function body is executed.
</li><li class="listitem">
Last, the class invariants and the function postconditions are checked.
</li></ol></div><p>
For example, if there is a bug in the function caller for which <code class="computeroutput"><span class="identifier">push_back</span></code> is called when <code class="computeroutput"><span class="identifier">size</span></code>
is equal to <code class="computeroutput"><span class="identifier">max_size</span></code> then the
execution of the program will be interrupted reporting a failure of the first
assertion in the preconditions and it will be evident that the bug is in the
caller:
</p><pre class="programlisting">precondition number 1 "size() &lt; max_size()" failed: file "push_back.cpp", line 26
</pre><p>
Instead, if there is a bug in the <code class="computeroutput"><span class="identifier">push_back</span></code>
implementation for which <code class="computeroutput"><span class="identifier">size</span></code>
is not increased by one after <code class="computeroutput"><span class="identifier">value</span></code>
is added to <code class="computeroutput"><span class="identifier">vector</span></code> by the function
body then the execution will be interrupted reporting a failure of the first
assertion in the postconditions and it will be evident that the bug is in
<code class="computeroutput"><span class="identifier">push_back</span></code> body:
</p><pre class="programlisting">postcondition number 1 "size() == old_size + 1" failed: file "push_back.cpp", line 26
</pre><p>
By default, when assertions fail this library prints the above error messages
to the standard error <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span></code> and it terminates the program calling
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span></code> (this behaviour can be customized
to throw an exception, exit the program, etc, see the <a class="link" href="#contract__.contract_programming_overview.broken_contracts" title="Broken Contracts">Broken
Contracts</a> section). Note that the library error messages contain enough
information to uniquely identify the contract failure: Assertion type (class
invariant, precondition, postcondition, etc), assertion number, asserted expression,
file name, and line number. (The line number refers to the single line on which
each macro expands so it will be the same for class invariants, preconditions,
and postconditions of a given class or function but it can still be used together
with the assertion number to uniquely identity which assertion failed.)
</p><h4><a name="contract__.introduction.h1"></a>
<span><a name="contract__.introduction.language_support"></a></span><a class="link" href="#contract__.introduction.language_support">Language
Support</a>
</h4><p>
This library suffers of two limitations:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
The unusual syntax used to declare classes and functions within the macros
which causes cryptic compiler errors when not used correctly (syntax error
checking and reporting could be somewhat improved in future revisions of
the library but there are fundamental limitations on what can be done using
the preprocessor, see also the <a class="link" href="#syntax_error_warning_anchor">Grammar</a>
section).
</li><li class="listitem">
High compilation times (the authors will try to reduce compilation times
in future revisions of the library, see also the <a class="link" href="#compilation_time_warning_anchor">Cost</a>
section).
</li></ol></div><p>
With the addition of contracts, concepts, and named parameters, C++ could introduce
formal program specification into main-stream programming. The authors wish
the work done in developing this library will persuade the C++ community and
the C++ standard committee to add these features to the core language so to
support formal program specification without the unusual macro syntax and avoiding
high compilation times (unfortunately, this has not been the direction taken
for <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a> with
the rejection of the concept proposal <a class="link" href="#N2081_anchor">[N2081]</a>
and the lack of consideration for the Contract Programming proposal <a class="link" href="#N1962_anchor">[N1962]</a>,
but there might still be hope for C++1x with x &gt; 1).
</p></div><div class="section" title="Full Table of Contents"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.full_table_of_contents"></a><a class="link" href="#contract__.full_table_of_contents" title="Full Table of Contents">Full Table of Contents</a></h2></div></div></div><pre class="programlisting"><a class="link" href="#contract__.introduction" title="Introduction">Introduction</a>
<a class="link" href="#contract__.full_table_of_contents" title="Full Table of Contents">Full Table Of Contents</a>
<a class="link" href="#contract__.getting_started" title="Getting Started">Getting Started</a>
<a class="link" href="#contract__.getting_started.this_documentation" title="This Documentation">This Documentation</a>
<a class="link" href="#contract__.getting_started.compilers_and_platforms" title="Compilers and Platforms">Compilers and Platforms</a>
<a class="link" href="#contract__.getting_started.installation" title="Installation">Installation</a>
<a class="link" href="#contract__.getting_started.disable_contract_compilation" title="Disable Contract Compilation">Disable Contract Compilation</a>
<a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract Programming Overview</a>
<a class="link" href="#contract__.contract_programming_overview.assertions" title="Assertions">Assertions</a>
<a class="link" href="#contract__.contract_programming_overview.benefits" title="Benefits">Benefits</a>
<a class="link" href="#contract__.contract_programming_overview.costs" title="Costs">Costs</a>
<a class="link" href="#contract__.contract_programming_overview.free_function_calls" title="Free Function Calls">Free Function Calls</a>
<a class="link" href="#contract__.contract_programming_overview.member_function_calls" title="Member Function Calls">Member Function Calls</a>
<a class="link" href="#contract__.contract_programming_overview.constructor_calls" title="Constructor Calls">Constructor Calls</a>
<a class="link" href="#contract__.contract_programming_overview.destructor_calls" title="Destructor Calls">Destructor Calls</a>
<a class="link" href="#contract__.contract_programming_overview.constant_correctness" title="Constant-Correctness">Constant-Correctness</a>
<a class="link" href="#contract__.contract_programming_overview.specification_vs__implementation" title="Specification vs. Implementation">Specification vs. Implementation</a>
<a class="link" href="#contract__.contract_programming_overview.broken_contracts" title="Broken Contracts">Broken Contracts</a>
<a class="link" href="#contract__.contract_programming_overview.features" title="Features">Features</a>
<a class="link" href="#contract__.tutorial" title="Tutorial">Tutorial</a>
<a class="link" href="#contract__.tutorial.free_functions" title="Free Functions">Free Functions</a>
<a class="link" href="#contract__.tutorial.preconditions" title="Preconditions">Preconditions</a>
<a class="link" href="#contract__.tutorial.postconditions__result_and_old_values_" title="Postconditions (Result and Old Values)">Postconditions (Result and Old Values)</a>
<a class="link" href="#contract__.tutorial.classes_and_class_invariants" title="Classes and Class Invariants">Classes and Class Invariants</a>
<a class="link" href="#contract__.tutorial.constructors" title="Constructors">Constructors</a>
<a class="link" href="#contract__.tutorial.destructors" title="Destructors">Destructors</a>
<a class="link" href="#contract__.tutorial.member_functions" title="Member Functions">Member Functions</a>
<a class="link" href="#contract__.tutorial.inheritance_and_subcontracting" title="Inheritance and Subcontracting">Inheritance and Subcontracting</a>
<a class="link" href="#contract__.tutorial.class_templates" title="Class Templates">Class Templates</a>
<a class="link" href="#contract__.tutorial.function_templates" title="Function Templates">Function Templates</a>
<a class="link" href="#contract__.tutorial.forward_declarations_and_body_definitions" title="Forward Declarations and Body Definitions">Forward Declarations and Body Definitions</a>
<a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced Topics</a>
<a class="link" href="#contract__.advanced_topics.commas_and_leading_symbols_in_macros" title="Commas and Leading Symbols in Macros">Commas and Leading Symbols in Macros</a>
<a class="link" href="#contract__.advanced_topics.static_assertions" title="Static Assertions">Static Assertions</a>
<a class="link" href="#contract__.advanced_topics.constant_assertions" title="Constant Assertions">Constant Assertions</a>
<a class="link" href="#contract__.advanced_topics.select_assertions" title="Select Assertions">Select Assertions</a>
<a class="link" href="#contract__.advanced_topics.assertion_statements" title="Assertion Statements">Assertion Statements</a>
<a class="link" href="#contract__.advanced_topics.assertion_requirements" title="Assertion Requirements">Assertion Requirements</a>
<a class="link" href="#contract__.advanced_topics.old_of_requirements" title="Old-Of Requirements">Old-Of Requirements</a>
<a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies">Old and Result Value Copies</a>
<a class="link" href="#contract__.advanced_topics.pure_virtual_functions" title="Pure Virtual Functions">Pure Virtual Functions</a>
<a class="link" href="#contract__.advanced_topics.subcontracting_preconditions" title="Subcontracting Preconditions">Subcontracting Preconditions</a>
<a class="link" href="#contract__.advanced_topics.static_member_functions" title="Static Member Functions">Static Member Functions</a>
<a class="link" href="#contract__.advanced_topics.volatile_member_functions" title="Volatile Member Functions">Volatile Member Functions</a>
<a class="link" href="#contract__.advanced_topics.operators" title="Operators">Operators</a>
<a class="link" href="#contract__.advanced_topics.nested_classes" title="Nested Classes">Nested Classes</a>
<a class="link" href="#contract__.advanced_topics.friends" title="Friends">Friends</a>
<a class="link" href="#contract__.advanced_topics.template_specializations" title="Template Specializations">Template Specializations</a>
<a class="link" href="#contract__.advanced_topics.exception_specifications_and_function_try_blocks" title="Exception Specifications and Function-Try Blocks">Exception Specifications and Function-Try Blocks</a>
<a class="link" href="#contract__.advanced_topics.specifying_types__no_boost_typeof_" title="Specifying Types (no Boost.Typeof)">Specifying Types (no Boost.Typeof)</a>
<a class="link" href="#contract__.advanced_topics.block_invariants_and_loop_variants" title="Block Invariants and Loop Variants">Block Invariants and Loop Variants</a>
<a class="link" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_" title="Contract Broken Handlers (Throw on Failure)">Contract Broken Handlers (Throw on Failure)</a>
<a class="link" href="#contract__.virtual_specifiers" title="Virtual Specifiers">Virtual Specifiers</a>
<a class="link" href="#contract__.virtual_specifiers.final_classes" title="Final Classes">Final Classes</a>
<a class="link" href="#contract__.virtual_specifiers.final_member_functions" title="Final Member Functions">Final Member Functions</a>
<a class="link" href="#contract__.virtual_specifiers.overriding_member_functions" title="Overriding Member Functions">Overriding Member Functions</a>
<a class="link" href="#contract__.virtual_specifiers.new_member_functions" title="New Member Functions">New Member Functions</a>
<a class="link" href="#contract__.concepts" title="Concepts">Concepts</a>
<a class="link" href="#contract__.concepts.class_templates" title="Class Templates">Class Templates</a>
<a class="link" href="#contract__.concepts.function_templates" title="Function Templates">Function Templates</a>
<a class="link" href="#contract__.concepts.concept_definitions__not_implemented_" title="Concept Definitions (Not Implemented)">Concept Definitions (Not Implemented)</a>
<a class="link" href="#contract__.named_parameters" title="Named Parameters">Named Parameters</a>
<a class="link" href="#contract__.named_parameters.overview" title="Overview">Overview</a>
<a class="link" href="#contract__.named_parameters.named_function_parameters" title="Named Function Parameters">Named Function Parameters</a>
<a class="link" href="#contract__.named_parameters.deduced_function_parameters" title="Deduced Function Parameters">Deduced Function Parameters</a>
<a class="link" href="#contract__.named_parameters.member_function_parameters" title="Member Function Parameters">Member Function Parameters</a>
<a class="link" href="#contract__.named_parameters.constructor_parameters" title="Constructor Parameters">Constructor Parameters</a>
<a class="link" href="#contract__.named_parameters.class_template_parameters" title="Class Template Parameters">Class Template Parameters</a>
<a class="link" href="#contract__.named_parameters.concepts" title="Concepts">Concepts</a>
<a class="link" href="#contract__.named_parameters.parameter_identifiers" title="Parameter Identifiers">Parameter Identifiers</a>
<a class="link" href="#contract__.examples" title="Examples">Examples</a>
<a class="link" href="#contract__.examples.__n1962___vector__comparison_with_c___proposed_syntax" title="[N1962] Vector: Comparison with C++ proposed syntax">[N1962] Vector: Comparison with C++ proposed syntax</a>
<a class="link" href="#contract__.examples.__n1962___circle__subcontracting" title="[N1962] Circle: Subcontracting">[N1962] Circle: Subcontracting</a>
<a class="link" href="#contract__.examples.__n1962___factorial__recursion_and_assertion_computational_complexity" title="[N1962] Factorial: Recursion and assertion computational complexity">[N1962] Factorial: Recursion and assertion computational complexity</a>
<a class="link" href="#contract__.examples.__n1962___equal__operators" title="[N1962] Equal: Operators">[N1962] Equal: Operators</a>
<a class="link" href="#contract__.examples.__n1962___sum__separated_body_definitions" title="[N1962] Sum: Separated body definitions">[N1962] Sum: Separated body definitions</a>
<a class="link" href="#contract__.examples.__n1962___square_root__default_parameters_and_comparison_with_d_syntax" title="[N1962] Square Root: Default parameters and comparison with D syntax">[N1962] Square Root: Default parameters and comparison with D syntax</a>
<a class="link" href="#contract__.examples.__n1962___block__block_invariants" title="[N1962] Block: Block invariants">[N1962] Block: Block invariants</a>
<a class="link" href="#contract__.examples.__n2081___add__generic_addition_algorithm" title="[N2081] Add: Generic addition algorithm">[N2081] Add: Generic addition algorithm</a>
<a class="link" href="#contract__.examples.__n2081___advance__concept_based_iterator_overloading__emulated_using_tags_" title="[N2081] Advance: Concept-based iterator overloading (emulated using tags)">[N2081] Advance: Concept-based iterator overloading (emulated using tags)</a>
<a class="link" href="#contract__.examples.__n2081___find__generic_find_algorithm" title="[N2081] Find: Generic find algorithm">[N2081] Find: Generic find algorithm</a>
<a class="link" href="#contract__.examples.__n2081___apply__overloaded_invocation_of_functors" title="[N2081] Apply: Overloaded invocation of functors">[N2081] Apply: Overloaded invocation of functors</a>
<a class="link" href="#contract__.examples.__n2081___for_each__generic_for_each_algorithm" title="[N2081] For Each: Generic for-each algorithm">[N2081] For Each: Generic for-each algorithm</a>
<a class="link" href="#contract__.examples.__n2081___transform__generic_binary_transformation_algorithm" title="[N2081] Transform: Generic binary transformation algorithm">[N2081] Transform: Generic binary transformation algorithm</a>
<a class="link" href="#contract__.examples.__n2081___count__generic_counting_algorithm" title="[N2081] Count: Generic counting algorithm">[N2081] Count: Generic counting algorithm</a>
<a class="link" href="#contract__.examples.__n2081___convert__conversion_between_two_types" title="[N2081] Convert: Conversion between two types">[N2081] Convert: Conversion between two types</a>
<a class="link" href="#contract__.examples.__n2081___equal__generic_equality_comparison" title="[N2081] Equal: Generic equality comparison">[N2081] Equal: Generic equality comparison</a>
<a class="link" href="#contract__.examples.__n2081___less_equal__generic_less_than_or_equal_to_comparison" title="[N2081] Less Equal: Generic less-than or equal-to comparison">[N2081] Less Equal: Generic less-than or equal-to comparison</a>
<a class="link" href="#contract__.examples.__n2081___de_ref__generic_iterator_dereferencing" title="[N2081] De-Ref: Generic iterator dereferencing">[N2081] De-Ref: Generic iterator dereferencing</a>
<a class="link" href="#contract__.examples.__n2081___min__generic_minimum_algorithm" title="[N2081] Min: Generic minimum algorithm">[N2081] Min: Generic minimum algorithm</a>
<a class="link" href="#contract__.examples.__meyer97___stack4__comparison_with_eiffel_syntax" title="[Meyer97] Stack4: Comparison with Eiffel syntax">[Meyer97] Stack4: Comparison with Eiffel Syntax</a>
<a class="link" href="#contract__.examples.__meyer97___stack3__error_codes_instead_of_preconditions" title="[Meyer97] Stack3: Error codes instead of preconditions">[Meyer97] Stack3: Error codes instead of preconditions</a>
<a class="link" href="#contract__.examples.__meyer97___gcd__loop_variants_and_invariants_plus_comparison_with_eiffel_syntax" title="[Meyer97] GCD: Loop variants and invariants plus comparison with Eiffel syntax">[Meyer97] GCD: Loop variants and invariants plus comparison with Eiffel syntax</a>
<a class="link" href="#contract__.examples.__meyer97___max_array__nested_loop_variants_and_invariants" title="[Meyer97] Max-Array: Nested loop variants and invariants">[Meyer97] Max-Array: Nested loop variants and invariants</a>
<a class="link" href="#contract__.examples.__mitchell02___name_list__relaxed_subcontracts" title="[Mitchell02] Name List: Relaxed subcontracts">[Mitchell02] Name List: Relaxed subcontracts</a>
<a class="link" href="#contract__.examples.__mitchell02___dictionary__simple_key_value_map" title="[Mitchell02] Dictionary: Simple key-value map">[Mitchell02] Dictionary: Simple key-value map</a>
<a class="link" href="#contract__.examples.__mitchell02___courier__subcontracting_and_static_class_invariants" title="[Mitchell02] Courier: Subcontracting and static class invariants">[Mitchell02] Courier: Subcontracting and static class invariants</a>
<a class="link" href="#contract__.examples.__mitchell02___stack__simple_stack_dispenser" title="[Mitchell02] Stack: Simple stack dispenser">[Mitchell02] Stack: Simple stack dispenser</a>
<a class="link" href="#contract__.examples.__mitchell02___simple_queue__simple_queue_dispenser" title="[Mitchell02] Simple Queue: Simple queue dispenser">[Mitchell02] Simple Queue: Simple queue dispenser</a>
<a class="link" href="#contract__.examples.__mitchell02___customer_manager__contracts_instead_of_defensive_programming" title="[Mitchell02] Customer Manager: Contracts instead of Defensive Programming">[Mitchell02] Customer Manager: Contracts instead of Defensive Programming</a>
<a class="link" href="#contract__.examples.__mitchell02___observer__contracts_for_pure_virtual_functions" title="[Mitchell02] Observer: Contracts for pure virtual functions">[Mitchell02] Observer: Contracts for pure virtual functions</a>
<a class="link" href="#contract__.examples.__mitchell02___counter__subcontracting_and_virtual_specifiers__final__override__new__and_pure_virtual_" title="[Mitchell02] Counter: Subcontracting and virtual specifiers (final, override, new, and pure virtual)">[Mitchell02] Counter: Subcontracting and virtual specifiers (final, override, new, and pure virtual)</a>
<a class="link" href="#contract__.examples.__stroustrup97___string__throw_when_contract_is_broken" title="[Stroustrup97] String: Throw when contract is broken">[Stroustrup97] String: Throw when contract is broken</a>
<a class="link" href="#contract__.examples.__cline90___vector__comparison_with_a___proposed_syntax" title="[Cline90] Vector: Comparison with A++ proposed syntax">[Cline90] Vector: Comparison with A++ proposed syntax</a>
<a class="link" href="#contract__.examples.__cline90___stack__function_try_blocks_and_exception_specifications" title="[Cline90] Stack: Function-Try blocks and exception specifications">[Cline90] Stack: Function-Try blocks and exception specifications</a>
<a class="link" href="#contract__.examples.__cline90___vector_stack__subcontracting_from_abstract_data_type__adt_" title="[Cline90] Vector-Stack: Subcontracting from Abstract Data Type (ADT)">[Cline90] Vector-Stack: Subcontracting from Abstract Data Type (ADT)</a>
<a class="link" href="#contract__.examples.__cline90___calendar__a_very_simple_calendar" title="[Cline90] Calendar: A very simple calendar">[Cline90] Calendar: A very simple calendar</a>
<a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
<a class="link" href="#contract__.grammar.preprocessor_dsel" title="Preprocessor DSEL">Preprocessor DSEL</a>
<a class="link" href="#contract__.grammar.differences_with_c___syntax" title="Differences with C++ Syntax">Differences with C++ Syntax</a>
<a class="link" href="#contract__.grammar.macro_interface" title="Macro Interface">Macro Interface</a>
<a class="link" href="#contract__.grammar.lexical_conventions" title="Lexical Conventions">Lexical Conventions</a>
<a class="link" href="#contract__.grammar.class_declarations" title="Class Declarations">Class Declarations</a>
<a class="link" href="#contract__.grammar.base_classes" title="Base Classes">Base Classes</a>
<a class="link" href="#contract__.grammar.template_specializations" title="Template Specializations">Template Specializations</a>
<a class="link" href="#contract__.grammar.template_parameters" title="Template Parameters">Template Parameters</a>
<a class="link" href="#contract__.grammar.concepts" title="Concepts">Concepts</a>
<a class="link" href="#contract__.grammar.types" title="Types">Types</a>
<a class="link" href="#contract__.grammar.function_declarations" title="Function Declarations">Function Declarations</a>
<a class="link" href="#contract__.grammar.result_type" title="Result Type">Result Type</a>
<a class="link" href="#contract__.grammar.function_and_operator_names" title="Function and Operator Names">Function and Operator Names</a>
<a class="link" href="#contract__.grammar.exception_specifications" title="Exception Specifications">Exception Specifications</a>
<a class="link" href="#contract__.grammar.member_initializers" title="Member Initializers">Member Initializers</a>
<a class="link" href="#contract__.grammar.function_parameters" title="Function Parameters">Function Parameters</a>
<a class="link" href="#contract__.grammar.result_and_old_values" title="Result and Old Values">Result and Old Values</a>
<a class="link" href="#contract__.grammar.class_invariants" title="Class Invariants">Class Invariants</a>
<a class="link" href="#contract__.grammar.assertions" title="Assertions">Assertions</a>
<a class="link" href="#contract__.grammar.loop_variants" title="Loop Variants">Loop Variants</a>
<a class="link" href="#contract__.grammar.named_parameter_declarations" title="Named Parameter Declarations">Named Parameter Declarations</a>
<a class="link" href="#contract__.grammar.terminals" title="Terminals">Terminals</a>
<a class="link" href="#contract__.grammar.alternative_assertion_syntax__not_implemented_" title="Alternative Assertion Syntax (Not Implemented)">Alternative Assertion Syntax (Not Implemented)</a>
<a class="link" href="#contract__.no_variadic_macros" title="No Variadic Macros">No Variadic Macros</a>
<a class="link" href="#contract__.no_variadic_macros.sequence_syntax" title="Sequence Syntax">Sequence Syntax</a>
<a class="link" href="#contract__.no_variadic_macros.commas_and_leading_symbols_in_macros" title="Commas and Leading Symbols in Macros">Commas and Leading Symbols in Macros</a>
<a class="link" href="#reference" title="Reference">Reference</a>
<code class="computeroutput"><a class="link" href="#contract.block_invariant_broken" title="Function block_invariant_broken">contract::block_invariant_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.broken" title="Class broken">contract::broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.broken_contract_handler" title="Type definition broken_contract_handler">contract::broken_contract_handler</a></code>
<code class="computeroutput"><a class="link" href="#contract.class_invariant_b_id485392" title="Function class_invariant_broken_on_entry">contract::class_invariant_broken_on_entry</a></code>
<code class="computeroutput"><a class="link" href="#contract.class_invariant_b_id485470" title="Function class_invariant_broken_on_exit">contract::class_invariant_broken_on_exit</a></code>
<code class="computeroutput"><a class="link" href="#contract.class_invariant_b_id485548" title="Function class_invariant_broken_on_throw">contract::class_invariant_broken_on_throw</a></code>
<code class="computeroutput"><a class="link" href="#contract.copy" title="Class template copy">contract::copy</a></code>
<code class="computeroutput"><a class="link" href="#contract.from" title="Type from">contract::from</a></code>
<code class="computeroutput"><a class="link" href="#contract.has_oldof" title="Struct template has_oldof">contract::has_oldof</a></code>
<code class="computeroutput"><a class="link" href="#contract.loop_variant_broken" title="Function loop_variant_broken">contract::loop_variant_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.postcondition_broken" title="Function postcondition_broken">contract::postcondition_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.precondition_broken" title="Function precondition_broken">contract::precondition_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_block_invariant_broken">contract::set_block_invariant_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_class_invariant_broken">contract::set_class_invariant_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485380">contract::set_class_invariant_broken_on_entry</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485458">contract::set_class_invariant_broken_on_exit</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485536">contract::set_class_invariant_broken_on_throw</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_loop_variant_broken">contract::set_loop_variant_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_postcondition_broken">contract::set_postcondition_broken</a></code>
<code class="computeroutput"><a class="link" href="#contract.set_precondition_broken">contract::set_precondition_broken</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT" title="Macro CONTRACT_BLOCK_INVARIANT">CONTRACT_BLOCK_INVARIANT</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT_TPL" title="Macro CONTRACT_BLOCK_INVARIANT_TPL">CONTRACT_BLOCK_INVARIANT_TPL</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT_TPL" title="Macro CONTRACT_CLASS_INVARIANT_TPL">CONTRACT_CLASS_INVARIANT_TPL</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_TPL" title="Macro CONTRACT_CLASS_TPL">CONTRACT_CLASS_TPL</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_ARRAY_DIMENSION_MAX" title="Macro CONTRACT_CONFIG_ARRAY_DIMENSION_MAX">CONTRACT_CONFIG_ARRAY_DIMENSION_MAX</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS" title="Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS">CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_FUNCTION_ARITY_MAX" title="Macro CONTRACT_CONFIG_FUNCTION_ARITY_MAX">CONTRACT_CONFIG_FUNCTION_ARITY_MAX</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_INHERITANCE_MAX" title="Macro CONTRACT_CONFIG_INHERITANCE_MAX">CONTRACT_CONFIG_INHERITANCE_MAX</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_BLOCK_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_BLOCK_INVARIANTS">CONTRACT_CONFIG_NO_BLOCK_INVARIANTS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_LOOP_VARIANTS" title="Macro CONTRACT_CONFIG_NO_LOOP_VARIANTS">CONTRACT_CONFIG_NO_LOOP_VARIANTS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_OLDOF_MAX" title="Macro CONTRACT_CONFIG_OLDOF_MAX">CONTRACT_CONFIG_OLDOF_MAX</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION" title="Macro CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION">CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE" title="Macro CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE">CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_THREAD_SAFE" title="Macro CONTRACT_CONFIG_THREAD_SAFE">CONTRACT_CONFIG_THREAD_SAFE</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_ARG" title="Macro CONTRACT_CONSTRUCTOR_ARG">CONTRACT_CONSTRUCTOR_ARG</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_BODY" title="Macro CONTRACT_CONSTRUCTOR_BODY">CONTRACT_CONSTRUCTOR_BODY</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_TPL" title="Macro CONTRACT_CONSTRUCTOR_TPL">CONTRACT_CONSTRUCTOR_TPL</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_BODY" title="Macro CONTRACT_DESTRUCTOR_BODY">CONTRACT_DESTRUCTOR_BODY</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_TPL" title="Macro CONTRACT_DESTRUCTOR_TPL">CONTRACT_DESTRUCTOR_TPL</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION_TPL" title="Macro CONTRACT_FUNCTION_TPL">CONTRACT_FUNCTION_TPL</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES" title="Macro CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES">CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS" title="Macro CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS">CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_OLDOFS" title="Macro CONTRACT_LIMIT_OLDOFS">CONTRACT_LIMIT_OLDOFS</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_LOOP" title="Macro CONTRACT_LOOP">CONTRACT_LOOP</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT" title="Macro CONTRACT_LOOP_VARIANT">CONTRACT_LOOP_VARIANT</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT_TPL" title="Macro CONTRACT_LOOP_VARIANT_TPL">CONTRACT_LOOP_VARIANT_TPL</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_BODY" title="Macro CONTRACT_PARAMETER_BODY">CONTRACT_PARAMETER_BODY</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_TYPEOF" title="Macro CONTRACT_PARAMETER_TYPEOF">CONTRACT_PARAMETER_TYPEOF</a></code>
<code class="computeroutput"><a class="link" href="#CONTRACT_TEMPLATE_PARAMETER" title="Macro CONTRACT_TEMPLATE_PARAMETER">CONTRACT_TEMPLATE_PARAMETER</a></code>
<a class="link" href="#contract__.release_notes" title="Release Notes">Release Notes</a>
<a class="link" href="#contract__.release_notes.release_0_4_0" title="Release 0.4.0">Release 0.4.0</a>
<a class="link" href="#contract__.release_notes.release_0_3_490" title="Release 0.3.490">Release 0.3.490</a>
<a class="link" href="#contract__.release_notes.release_0_3_469" title="Release 0.3.469">Release 0.3.469</a>
<a class="link" href="#contract__.release_notes.release_0_2_190" title="Release 0.2.190">Release 0.2.190</a>
<a class="link" href="#contract__.release_notes.release_0_1_126" title="Release 0.1.126">Release 0.1.126</a>
<a class="link" href="#contract__.release_notes.release_0_1_55" title="Release 0.1.55">Release 0.1.55</a>
<a class="link" href="#contract__.release_notes.release_0_1_50" title="Release 0.1.50">Release 0.1.50</a>
<a class="link" href="#contract__.bibliography" title="Bibliography">Bibliography</a>
<a class="link" href="#contract__.acknowledgments" title="Acknowledgments">Acknowledgments</a>
</pre></div><div class="section" title="Getting Started"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.getting_started"></a><a class="link" href="#contract__.getting_started" title="Getting Started">Getting Started</a></h2></div></div></div><p>
This section explains how to setup a system to use this library.
</p><div class="section" title="This Documentation"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.getting_started.this_documentation"></a><a class="link" href="#contract__.getting_started.this_documentation" title="This Documentation">This Documentation</a></h3></div></div></div><p>
Programmers should have enough knowledge to use this library after reading
the <a class="link" href="#contract__.introduction" title="Introduction">Introduction</a>, <a class="link" href="#contract__.getting_started" title="Getting Started">Getting
Started</a>, and <a class="link" href="#contract__.tutorial" title="Tutorial">Tutorial</a> sections.
The other sections can be consulted to gain a more in depth knowledge of
the library.
</p><p>
Some footnotes are marked by the word "<span class="bold"><strong>Rationale</strong></span>".
They explain reasons behind decisions made during the design and implementation
of this library.
</p><p>
In most of the examples presented in this documentation the Boost.Detail/LightweightTest
macro <code class="computeroutput"><span class="identifier">BOOST_TEST</span></code> is used
to assert test conditions (see also <code class="literal">boost/detail/lightweight_test.hpp</code>).
The <code class="computeroutput"><span class="identifier">BOOST_TEST</span></code> macro is conceptually
similar to C++ <code class="computeroutput"><span class="identifier">assert</span></code> but
a failure of the checked condition does not abort the program, instead it
makes <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span></code> return a non-zero program
exit code. <sup>[<a name="contract__.getting_started.this_documentation.f0" href="#ftn.contract__.getting_started.this_documentation.f0" class="footnote">2</a>]</sup>
</p></div><div class="section" title="Compilers and Platforms"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.getting_started.compilers_and_platforms"></a><a class="link" href="#contract__.getting_started.compilers_and_platforms" title="Compilers and Platforms">Compilers
and Platforms</a></h3></div></div></div><p>
The implementation of this library uses preprocessor and template meta-programming
(as supported by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/preprocessor" target="_top">Boost.Preprocessor</a>
and <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/mpl" target="_top">Boost.MPL</a>
respectively), templates with partial specializations and function pointers
(similarly to <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/function" target="_top">Boost.Function</a>),
and local functions (as supported by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/local_function" target="_top">Boost.LocalFunction</a>).
The authors originally developed and tested the library on:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
GCC 4.5.3 on Cygwin (with and without <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
features enabled <code class="literal">-std=c++0x</code>). <sup>[<a name="contract__.getting_started.compilers_and_platforms.f0" href="#ftn.contract__.getting_started.compilers_and_platforms.f0" class="footnote">3</a>]</sup>
</li><li class="listitem">
Microsoft Visual C++ (MSVC) 8.0 on Windows XP and Windows 7.
</li></ol></div><p>
At present, the library has not been tested on other compilers or platforms.
</p></div><div class="section" title="Installation"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.getting_started.installation"></a><a class="link" href="#contract__.getting_started.installation" title="Installation">Installation</a></h3></div></div></div><p>
This library is composed of header files only. Therefore there is no pre-compiled
object file which needs to be installed or linked. Programmers can simply
instruct the C++ compiler where to find the library header files and they
can start compiling code using this library.
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
This library extensively uses <a class="ulink" href="http://www.boost.org" target="_top">Boost</a>
libraries. <a class="ulink" href="http://www.boost.org" target="_top">Boost</a> version 1.50
must be properly installed in order for this library to compile.
</p></td></tr></table></div><p>
Let <span class="emphasis"><em><code class="literal">ROOT</code></em></span> be the root directory of
this library installation then the directory structure is as follow:
</p><pre class="programlisting"><span class="emphasis"><em>ROOT</em></span>/
doc/
html/ # This HTML documentation.
example/ # Examples using this library.
include/ # This library source files (headers only).
</pre><p>
For example, the following commands can be used to compile code using this
library: <sup>[<a name="contract__.getting_started.installation.f0" href="#ftn.contract__.getting_started.installation.f0" class="footnote">4</a>]</sup>
</p><pre class="programlisting">$ g++ -I <span class="emphasis"><em>ROOT</em></span>/include ... # For GCC.
&gt; cl /I <span class="emphasis"><em>ROOT</em></span>\include ... # For MSVC.
</pre><p>
All necessary library headers are included in the source code by the following
instruction (it is not necessary to include single headers separately):
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// Include this library headers.</span>
</pre><p>
The following symbols are part of the library private interface, they are
not documented, and they should not be directly used by programmers: <sup>[<a name="contract__.getting_started.installation.f1" href="#ftn.contract__.getting_started.installation.f1" class="footnote">5</a>]</sup>
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Any symbol defined by files within the <code class="literal">contract/aux_/</code>
or <code class="literal">contract/detail/</code> directories (these header files
should not be directly included by programmers).
</li><li class="listitem">
Any symbol within the <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">aux</span></code>
or <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">detail</span></code> namespace.
</li><li class="listitem">
Any symbol prefixed by <code class="computeroutput"><span class="identifier">contract_aux_</span><span class="special">...</span></code> or <code class="computeroutput"><span class="identifier">contract_detail_</span><span class="special">...</span></code> (regardless of its namespace).
</li><li class="listitem">
Any symbol prefixed by <code class="computeroutput"><span class="identifier">CONTRACT_AUX_</span><span class="special">...</span></code> or <code class="computeroutput"><span class="identifier">CONTRACT_DETAIL_</span><span class="special">...</span></code> (regardless of its namespace).
</li></ul></div><p>
Symbols starting with <code class="computeroutput"><span class="identifier">ERROR_</span><span class="special">...</span></code> are used to report compile-time errors
via static assertions and programmers should not use these symbols to define
macros or other constructs in the global namespace.
</p></div><div class="section" title="Disable Contract Compilation"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.getting_started.disable_contract_compilation"></a><a class="link" href="#contract__.getting_started.disable_contract_compilation" title="Disable Contract Compilation">Disable
Contract Compilation</a></h3></div></div></div><p>
Some of the library behaviour can be customized at compile-time by defining
special <span class="emphasis"><em>configuration macros</em></span> (see <code class="computeroutput"><a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a></code>).
In particular, the following configuration macros can be used to selectively
turn on or off contract compilation and the related run-time checks:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Defining the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>
macro turns off compilation and run-time checking of all preconditions.
</li><li class="listitem">
Defining the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>
macro turns off compilation and run-time checking of all postconditions.
</li><li class="listitem">
Defining the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>
macro turns off compilation and run-time checking of all class invariants.
</li><li class="listitem">
Defining the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_BLOCK_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_BLOCK_INVARIANTS">CONTRACT_CONFIG_NO_BLOCK_INVARIANTS</a></code>
macro turns off compilation and run-time checking of all block invariants.
</li><li class="listitem">
Defining the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_LOOP_VARIANTS" title="Macro CONTRACT_CONFIG_NO_LOOP_VARIANTS">CONTRACT_CONFIG_NO_LOOP_VARIANTS</a></code>
macro turns off compilation and run-time checking of all loop variants.
</li></ul></div><p>
By default, all contracts are compiled and checked at run-time (i.e., all
the macros above are not defined).
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
In Contract Programming, it is usually important to selectively turn off
contract compilation to reduce run-time, binary size, and compilation-time
overhead associated with the contracts (see <a class="link" href="#Meyer97_anchor">[Meyer97]</a>).
This library guarantees zero run-time and binary size overhead when all
contracts are all turned off (however, even when contracts are all turned
off there is a limited compile-time overhead associated with expanding
the contract macros to generate the original class and function declarations).
Note that when contracts are turned off their assertions are completely
ignored by the compiler so the assertion code might not even be syntactically
correct.
</p></td></tr></table></div><p>
For example, the following commands compile and check preconditions and class
invariants, but they do not compile and check postconditions, block invariants,
and loop variants:
</p><pre class="programlisting">$ g++ -DCONTRACT_CONFIG_NO_POSTCONDITONS -DCONTRACT_CONFIG_NO_BLOCK_INVARIANTS -DCONTRACT_CONFIG_NO_LOOP_VARIANTS ... # For GCC.
&gt; cl /DCONTRACT_CONFIG_NO_POSTCONDITONS /DCONTRACT_CONFIG_NO_BLOCK_INVARIANTS /DCONTRACT_CONFIG_NO_LOOP_VARIANTS ... # For MSVC.
</pre><p>
Other configuration macros are provided to customize other aspects of the
library. For example, the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_FUNCTION_ARITY_MAX" title="Macro CONTRACT_CONFIG_FUNCTION_ARITY_MAX">CONTRACT_CONFIG_FUNCTION_ARITY_MAX</a></code>
macro is used to specify the maximum number of function parameters and the
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_INHERITANCE_MAX" title="Macro CONTRACT_CONFIG_INHERITANCE_MAX">CONTRACT_CONFIG_INHERITANCE_MAX</a></code>
macro is used to specify the maxim number of base classes. All configuration
macros have appropriate default values when they are left undefined by programmers.
</p></div></div><div class="section" title="Contract Programming Overview"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.contract_programming_overview"></a><a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract Programming
Overview</a></h2></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
<span class="emphasis"><em><span class="quote">&#8220;<span class="quote">It is absurd to make elaborate security checks on debugging
runs, when no trust is put in the results, and then remove them in production
runs, when an erroneous result could be expensive or disastrous. What would
we think of a sailing enthusiast who wears his life-jacket when training
on dry land but takes it off as soon as he goes to sea?</span>&#8221;</span></em></span>
</p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
<span class="emphasis"><em>--Hoare (see <a class="link" href="#Hoare73_anchor">[Hoare73]</a>)</em></span>
</p></blockquote></div><p>
This section gives an overview of Contract Programming (see <a class="link" href="#Meyer97_anchor">[Meyer97]</a>,
<a class="link" href="#Mitchell02_anchor">[Mitchell02]</a>, and <a class="link" href="#N1613_anchor">[N1613]</a>
for a detailed introduction to Contract Programming).
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
The objective of this library is <span class="emphasis"><em>not</em></span> to convince programmers
to use Contract Programming. It is assumed that programmes understand the
benefits and trade-offs associated with Contract Programming and they have
already decided to use this methodology to formally program specifications.
Then, this library aims to be the best Contract Programming library for C++.
</p></td></tr></table></div><div class="section" title="Assertions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.assertions"></a><a class="link" href="#contract__.contract_programming_overview.assertions" title="Assertions">Assertions</a></h3></div></div></div><p>
Contract Programming is characterized by the following type of assertion
mechanisms.
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
Assertion
</p>
</th><th>
<p>
Purpose
</p>
</th></tr></thead><tbody><tr><td>
<p>
Preconditions
</p>
</td><td>
<p>
These are logical conditions that programmers expect to be true
when the function is called (e.g., to check constraints on the
function arguments).
</p>
</td></tr><tr><td>
<p>
Postconditions
</p>
</td><td>
<p>
These are logical conditions that programmers expect to be true
when the function has ended normally (e.g., to check the result
and any side effect that a function might have). Postconditions
can usually access the function result value (for non-void functions)
and <span class="emphasis"><em>old values</em></span> that expressions had before
the body execution.
</p>
</td></tr><tr><td>
<p>
Class Invariants
</p>
</td><td>
<p>
These are logical conditions that programmers expect to be true
after the constructor has been executed successfully, before and
after the execution of every non-static public member function,
and before the destructor is executed (e.g, class invariants can
define valid states of all objects of a class). It is possible
to describe a different set of class invariants for volatile member
functions but <span class="emphasis"><em>volatile class invariants</em></span> are
assumed to be same as class invariants unless differently specified.
It is also possible to describe <span class="emphasis"><em>static class invariants</em></span>
which are excepted to be true before and after the execution of
any public member function (even if static), including constructor
entry and destructor exit. <sup>[<a name="contract__.contract_programming_overview.assertions.f0" href="#ftn.contract__.contract_programming_overview.assertions.f0" class="footnote">a</a>]</sup>
</p>
</td></tr><tr><td>
<p>
Subcontracting
</p>
</td><td>
<p>
Subcontracting is defined using the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a> and it predicates that: Preconditions cannot
be strengthen, postconditions and class invariants cannot be weaken.
</p>
</td></tr><tr><td>
<p>
Block Invariants
</p>
</td><td>
<p>
These are logical conditions that programmers except to be true
every time the execution reaches the point where the condition
is asserted. When used within a loop (i.e., a block of code that
can be executed in iteration), block invariants are also called
<span class="emphasis"><em>loop invariants</em></span> and they assert conditions
that are expected to be true for every loop iteration.
</p>
</td></tr><tr><td>
<p>
Loop Variants
</p>
</td><td>
<p>
For a given loop, a <a class="ulink" href="http://en.wikipedia.org/wiki/Loop_variant" target="_top">loop
variant</a> is a non-negative integer expression (<code class="computeroutput"><span class="special">&gt;=</span> <span class="number">0</span></code>)
with a value that is expected to decrease at every subsequent loop
iteration. Loop variants are used to ensure that loops terminate
avoiding infinite iterations.
</p>
</td></tr></tbody><tbody class="footnotes"><tr><td colspan="2"><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.assertions.f0" href="#contract__.contract_programming_overview.assertions.f0" class="para">a</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Static and volatile
class invariants were first introduced by this library to reflect
the fact that C++ support both static and volatile member functions.
Static and volatile class invariants are not part of <a class="link" href="#N1962_anchor">[N1962]</a>.
</p></div></td></tr></tbody></table></div><p>
It is a common Contract Programming requirement to disable other contracts
while a contract assertions is being evaluated (in order to avoid infinite
recursive calls). This library implement this feature however it should be
noted that in order to globally disable assertions while checking another
assertion, some type of global variable needs to be used. In multi-threaded
environments, programmers can define the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_THREAD_SAFE" title="Macro CONTRACT_CONFIG_THREAD_SAFE">CONTRACT_CONFIG_THREAD_SAFE</a></code>
configuration macro to protect such a global variable from racing conditions
(but that will effectively introduce a global lock in the program).
</p><p>
A limited form of Contract Programming is the use of the C++ <code class="computeroutput"><span class="identifier">assert</span></code> macro. Using <code class="computeroutput"><span class="identifier">assert</span></code>
is common practice for many programmers but unfortunately it suffers from
the following problems (that are instead resolved by using Contract Programming):
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
<code class="computeroutput"><span class="identifier">assert</span></code> is used within
the implementation therefore the asserted conditions are not easily visible
to the caller which is only familiar with the class and function declarations.
</li><li class="listitem">
<code class="computeroutput"><span class="identifier">assert</span></code> does not distinguish
between preconditions and postconditions. In well-tested production code,
postconditions can be disabled trusting the correctness of the implementation
while preconditions might still need to remain enabled because of the
evolution of the calling code. Using <code class="computeroutput"><span class="identifier">assert</span></code>
it is not possible to selectively disable only postconditions and all
assertions must be disabled at once.
</li><li class="listitem">
<code class="computeroutput"><span class="identifier">assert</span></code> requires to manually
program extra code to check class invariants (e.g., extra member functions
and try blocks).
</li><li class="listitem">
<code class="computeroutput"><span class="identifier">assert</span></code> does not support
subcontracting.
</li></ol></div></div><div class="section" title="Benefits"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.benefits"></a><a class="link" href="#contract__.contract_programming_overview.benefits" title="Benefits">Benefits</a></h3></div></div></div><p>
The main use of Contract Programming is to improve software quality. <a class="link" href="#Meyer97_anchor">[Meyer97]</a> discusses how Contract Programming
can be used as the basic tool to write <span class="quote">&#8220;<span class="quote">correct</span>&#8221;</span> software. Furhtermore,
<a class="link" href="#Stroustrup97_anchor">[Stroustrup97]</a> discusses the key
importance of class invariants plus advantages and disadvantages of preconditions
and postconditions. The following is a short summary of the benefits associated
with Contract Programming mainly taken from <a class="link" href="#N1613_anchor">[N1613]</a>.
</p><div class="informaltable"><table border="1"><colgroup><col><col><col></colgroup><thead><tr><th>
<p>
#
</p>
</th><th>
<p>
Topic
</p>
</th><th>
<p>
Benefit
</p>
</th></tr></thead><tbody><tr><td>
<p>
1.
</p>
</td><td>
<p>
Preconditions and Postconditions
</p>
</td><td>
<p>
Using function preconditions and postconditions, programmers can
give a precise semantic description of what a function requires
at its entry and what it ensures under its (normal) exit. In particular,
using postcondition old values, Contract Programming provides a
mechanism that allows programmers to compare values of an expression
before and after the function body execution. This mechanism is
powerful enough to enable programmers to express many constraints
within the code, constraints that would otherwise have to be captured
at best only informally by the code documentation.
</p>
</td></tr><tr><td>
<p>
2.
</p>
</td><td>
<p>
Class Invariants
</p>
</td><td>
<p>
Using class invariants, programmers can describe what to expect
from a class and the logic dependencies between the class members.
It is the job of the constructor to ensure that the class invariants
are satisfied when the object is first created. Then the implementation
of the member functions can be largely simplified as they can be
written knowing that the class invariants are satisfied because
Contract Programing checks them before and after the execution
of every member function. Finally, the destructor makes sure that
the class invariants hold for the entire life of the object, checking
the class invariants one last time before the object is destructed.
</p>
</td></tr><tr><td>
<p>
3.
</p>
</td><td>
<p>
Self-Documenting Code
</p>
</td><td>
<p>
Contracts are part of the source code, they are executed and verified
at run-time so they are always up to date with the code itself.
Therefore the specifications, as documented by the contracts, can
be trusted to always be up to date with the implementation code.
</p>
</td></tr><tr><td>
<p>
4.
</p>
</td><td>
<p>
Easier Debugging
</p>
</td><td>
<p>
Contract Programming can provide a powerful debugging facility
because, if contracts are well written, bugs will cause contract
assertions to fail exactly where the problem first occurs instead
than at some later stage of the program execution in an apparently
unrelated manner. Note that a precondition failure points to a
bug in the function caller, a postcondition failure points instead
to a bug in the function implementation. Furthermore, in case of
contract failure, this library provides detailed error messages
that greatly helps debugging. <sup>[<a name="contract__.contract_programming_overview.benefits.f0" href="#ftn.contract__.contract_programming_overview.benefits.f0" class="footnote">a</a>]</sup>
</p>
</td></tr><tr><td>
<p>
5.
</p>
</td><td>
<p>
Easier Testing
</p>
</td><td>
<p>
Contract Programming facilitates testing because a contract naturally
specifies what a test should check. For example, preconditions
of a function state which inputs cause the function to fail and
postconditions state which outputs are produced by the function
on normal exit.
</p>
</td></tr><tr><td>
<p>
6.
</p>
</td><td>
<p>
Formal Design
</p>
</td><td>
<p>
Contract Programming can serve to reduce the gap between designers
and programmers by providing a precise and unambiguous specification
language. Moreover, contracts can make code reviews easier.
</p>
</td></tr><tr><td>
<p>
7.
</p>
</td><td>
<p>
Formal Inheritance
</p>
</td><td>
<p>
Contract Programming formalizes the virtual function overriding
mechanism using subcontracting as justified by the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a>. This keeps the base class programmers in control
as overriding functions still have to fully satisfy the base class
contracts.
</p>
</td></tr><tr><td>
<p>
8.
</p>
</td><td>
<p>
Replace Defensive Programming
</p>
</td><td>
<p>
Contract Programming assertions can replace <a class="ulink" href="http://en.wikipedia.org/wiki/Defensive_programming" target="_top">Defensive
Programming</a> checks localizing these checks within the contract
and making the code more readable.
</p>
</td></tr></tbody><tbody class="footnotes"><tr><td colspan="3"><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.benefits.f0" href="#contract__.contract_programming_overview.benefits.f0" class="para">a</a>] </sup>
Of course, if the contract is ill written then Contract Programming
is of little use. However, it is less likely to have a bug in
both the function body and the contract than in the function
body only. For example, consider the validation of a result in
postconditions. Validating the return value might seem redundant,
but in this case we actually want that redundancy. When programmers
write a function, there is a certain probability that they make
a mistake in implementing the function body. When programmers
specify the result of the function in the postconditions, there
is also a certain probability that they make a mistake in writing
the contract. However, the probability that programmers make
a mistake twice (in both the body <span class="emphasis"><em>and</em></span> the
contract) is lower than the probability that the mistake is made
just once (in either the body or the contract).
</p></div></td></tr></tbody></table></div></div><div class="section" title="Costs"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.costs"></a><a class="link" href="#contract__.contract_programming_overview.costs" title="Costs">Costs</a></h3></div></div></div><p>
Contract Programming benefits come to the cost of performance as discussed
in detail by both <a class="link" href="#Stroustrup97_anchor">[Stroustrup97]</a>
and <a class="link" href="#Meyer97_anchor">[Meyer97]</a>. However, while performance
trade-offs should be carefully considered depending on the specific application
domain, software quality cannot be sacrificed (it is difficult to see the
value of software that quickly and efficiently provides an incorrect result).
</p><p>
The run-time performances are negatively impacted by Contract Programming
mainly because of the following:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
The extra processing required to check the assertions.
</li><li class="listitem">
The extra processing required by the additional function calls (additional
functions are invoked to check preconditions, postconditions, class invariants,
etc).
</li><li class="listitem">
The extra processing required to copy expression results when old values
that are used in postconditions.
</li></ol></div><p>
To mitigate the run-time performance impact, programmers can selectively
turn off some of the contract compilation and the related run-time checking.
Programmers will have to decide based on the performance trade-offs required
by their applications but a reasonable approach usually is to:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Always write contracts to clarify the semantics of the design embedding
the specifications directly into the code and making the code self-documenting.
</li><li class="listitem">
Enable preconditions, postconditions, and class invariants compilation
and checking during initial testing.
</li><li class="listitem">
Enable only preconditions (and possibly class invariants) during release
testing and for the final release (see also <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>,
and <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>).
</li></ul></div><p>
This approach is usually reasonable because in well-tested production code,
validating the function body implementation using postconditions and class
invariants is rarely needed since the function has shown itself to be <span class="quote">&#8220;<span class="quote">correct</span>&#8221;</span>
during testing. On the other hand, checking function arguments using postconditions
is always needed because of the evolution of the calling code. Furthermore,
postconditions are usually computationally more expensive to check (see the
<a class="link" href="#contract__.advanced_topics.assertion_requirements" title="Assertion Requirements">Assertion
Requirements</a> section for a mechanism to selectively enable assertions
also based on their computational complexity).
</p><p>
Compile-time performances are also impacted by this library mainly because:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
The contracts appear in class and function declarations (usually header
files) so they have to be re-compiled for each translation unit.
</li><li class="listitem">
The library implementation extensively uses preprocessor and template
meta-programming which significantly stress compiler performances.
</li></ol></div><a name="compilation_time_warning_anchor"></a><div class="warning" title="Warning"><table border="0" summary="Warning"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../doc/src/images/warning.png"></td><th align="left">Warning</th></tr><tr><td align="left" valign="top"><p>
Unfortunately, the current implementation of this library significantly
slows down compilation. For example, for a project with 122 files and 15,471
lines of code, adding contracts to a total of 50 classes and 302 functions
increased compilation time from 1 minute to 26 minutes when compilation
was enabled for all contracts (debug build), and from 1 minute to 2 minutes
when contracts were left in the code but contract compilation was disabled
using this library configuration macros <code class="computeroutput"><span class="identifier">CONTRACT_CONFIG_NO_</span><span class="special">...</span></code> (release build). <sup>[<a name="contract__.contract_programming_overview.costs.f0" href="#ftn.contract__.contract_programming_overview.costs.f0" class="footnote">6</a>]</sup>
</p><p>
The authors have not done a detailed preprocessing-time and compile-time
analysis of the performances of this library. Therefore, the authors have
not yet tried to optimize this library compilation-time. Reducing compilation-time
will be a major focus of future releases (see also <a class="ulink" href="https://sourceforge.net/apps/trac/contractpp/ticket/48" target="_top">Ticket
48</a>).
</p></td></tr></table></div><p>
Finally, Contract Programming should be seen as a tool to complement (and
not to substitute) testing.
</p></div><div class="section" title="Free Function Calls"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.free_function_calls"></a><a class="link" href="#contract__.contract_programming_overview.free_function_calls" title="Free Function Calls">Free
Function Calls</a></h3></div></div></div><p>
A <span class="emphasis"><em>free function</em></span> <sup>[<a name="contract__.contract_programming_overview.free_function_calls.f0" href="#ftn.contract__.contract_programming_overview.free_function_calls.f0" class="footnote">7</a>]</sup> call executes the following steps:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Check the function preconditions.
</li><li class="listitem">
Execute the function body.
</li><li class="listitem">
Check the function postconditions.
</li></ol></div></div><div class="section" title="Member Function Calls"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.member_function_calls"></a><a class="link" href="#contract__.contract_programming_overview.member_function_calls" title="Member Function Calls">Member
Function Calls</a></h3></div></div></div><p>
A member function call executes the following steps:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Check the static class invariants.
</li><li class="listitem">
Check the non-static class invariants (in <a class="link" href="#logic_and_anchor">logic-and</a>
with the base class invariants when subcontracting). These are checked
only for non-static member functions. <sup>[<a name="contract__.contract_programming_overview.member_function_calls.f0" href="#ftn.contract__.contract_programming_overview.member_function_calls.f0" class="footnote">8</a>]</sup> Volatile member functions check volatile class invariants
instead.
</li><li class="listitem">
Check the function preconditions (in <a class="link" href="#logic_or_anchor">logic-or</a>
with the overridden function preconditions when subcontracting).
</li><li class="listitem">
Execute the function body.
</li><li class="listitem">
Check the static class invariants (even if the body throws an exception).
</li><li class="listitem">
Check the non-static class invariants (in <a class="link" href="#logic_and_anchor">logic-and</a>
with the base class invariants when subcontracting). These are checked
only for non-static member functions and even if the body throws an exception.
Volatile member functions check volatile class invariants instead.
</li><li class="listitem">
Check the function postconditions (in <a class="link" href="#logic_and_anchor">logic-and</a>
with the overridden function postconditions when subcontracting). These
are checked only if the body does not throw an exception.
</li></ol></div><p>
<a name="logic_and_anchor"></a><a name="logic_or_anchor"></a>In this documentation
<a class="link" href="#logic_and_anchor">logic-and</a> and <a class="link" href="#logic_or_anchor">logic-or</a>
are the logic <span class="emphasis"><em>and</em></span> and <span class="emphasis"><em>or</em></span> operations
evaluated in short-circuit:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
<code class="computeroutput"><span class="identifier">p</span></code> <a class="link" href="#logic_and_anchor">logic-and</a>
<code class="computeroutput"><span class="identifier">q</span></code> is true if and only
if both <code class="computeroutput"><span class="identifier">p</span></code> and <code class="computeroutput"><span class="identifier">q</span></code> are true but <code class="computeroutput"><span class="identifier">q</span></code>
is evaluated only when <code class="computeroutput"><span class="identifier">p</span></code>
is true.
</li><li class="listitem">
<code class="computeroutput"><span class="identifier">p</span></code> <a class="link" href="#logic_or_anchor">logic-or</a>
<code class="computeroutput"><span class="identifier">q</span></code> is true if and only
if either <code class="computeroutput"><span class="identifier">p</span></code> or <code class="computeroutput"><span class="identifier">q</span></code> is true but <code class="computeroutput"><span class="identifier">q</span></code>
is evaluated only when <code class="computeroutput"><span class="identifier">p</span></code>
is false.
</li></ul></div><p>
Class invariants are checked before preconditions and postconditions so that
preconditions and postconditions assertions can be simplified by being programmed
under the assumption that class invariants are satisfied (e.g., if class
invariants assert that a pointer cannot be null then preconditions and postconditions
can safety dereference the pointer without additional checking). Similarly,
subcontracting checks contracts of base classes before checking the derived
class contracts so that the base class contract can be programmed under the
assumption that the base class contracts are satisfied. When a member function
overrides more than one virtual base function because of multiple inheritance:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Class invariants are checked in <a class="link" href="#logic_and_anchor">logic-and</a>
with the class invariants of all base classes following the inheritance
order.
</li><li class="listitem">
Preconditions are checked in <a class="link" href="#logic_or_anchor">logic-or</a>
with the preconditions of all overridden functions following the inheritance
order.
</li><li class="listitem">
Postconditions are checked in <a class="link" href="#logic_and_anchor">logic-and</a>
with the postconditions of all overridden functions following the inheritance
order.
</li></ul></div><p>
Note that:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Preconditions and postconditions of static member functions cannot access
the object.
</li><li class="listitem">
Preconditions, postconditions, and volatile class invariants of volatile
member functions access the object as (constant) volatile.
</li></ul></div></div><div class="section" title="Constructor Calls"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.constructor_calls"></a><a class="link" href="#contract__.contract_programming_overview.constructor_calls" title="Constructor Calls">Constructor
Calls</a></h3></div></div></div><p>
A constructor call executes the following steps:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Check the constructor preconditions.
</li><li class="listitem">
Initialize base classes and members executing the constructor member
initialization list if present.
</li><li class="listitem">
Check the static class invariants (but not the non-static class invariants).
</li><li class="listitem">
Execute the constructor body.
</li><li class="listitem">
Check the static class invariants (even if the body throws an exception).
</li><li class="listitem">
Check the non-static class invariants, but only if the body did not throw
an exception.
</li><li class="listitem">
Check the constructor postconditions, but only if the body did not throw
an exception.
</li></ol></div><p>
Preconditions are checked before initializing base classes and members so
that these initializations can relay on preconditions to be true (for example
to validate constructor arguments before they are used to initialize member
variables). C++ object construction mechanism will automatically check base
class contracts when subcontracting.
</p><p>
Note that:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Non-static class invariants are not checked at constructor entry (because
there is no object before the constructor body is executed).
</li><li class="listitem">
Preconditions cannot access the object (because there is no object before
the constructor body is executed).
</li><li class="listitem">
Postconditions cannot access the object old value (because there was
no object before the constructor body was executed).
</li><li class="listitem">
The object is never volatile within constructors so constructors do not
check volatile class invariants.
</li></ul></div></div><div class="section" title="Destructor Calls"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.destructor_calls"></a><a class="link" href="#contract__.contract_programming_overview.destructor_calls" title="Destructor Calls">Destructor
Calls</a></h3></div></div></div><p>
A destructor call executes the following steps:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Check the static class invariants.
</li><li class="listitem">
Check the non-static class invariants.
</li><li class="listitem">
Execute the destructor body.
</li><li class="listitem">
Check the static class invariants (even if the body throws an exception).
<sup>[<a name="contract__.contract_programming_overview.destructor_calls.f0" href="#ftn.contract__.contract_programming_overview.destructor_calls.f0" class="footnote">9</a>]</sup>
</li><li class="listitem">
Check the non-static class invariants, but only if the body threw an
exception.
</li></ol></div><p>
C++ object destruction mechanism will automatically check base class contracts
when subcontracting.
</p><p>
Note that:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Destructors have no parameter and they can be called at any time after
object construction so they have no preconditions.
</li><li class="listitem">
After the destructor body is executed, the object no longer exists so
non-static class invariants do not have to be true and they are not checked
at destructor exit.
</li><li class="listitem">
Destructors have no postconditions because they have no parameter and
after the body execution there is no object. <sup>[<a name="contract__.contract_programming_overview.destructor_calls.f1" href="#ftn.contract__.contract_programming_overview.destructor_calls.f1" class="footnote">10</a>]</sup>
</li><li class="listitem">
The object is never volatile within destructors so destructors do not
check volatile class invariants.
</li></ul></div></div><div class="section" title="Constant-Correctness"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.constant_correctness"></a><a class="link" href="#contract__.contract_programming_overview.constant_correctness" title="Constant-Correctness">Constant-Correctness</a></h3></div></div></div><p>
Contracts are only responsible to check the program state in oder to ensure
its compliance with the specifications. Therefore, contracts should not be
able to modify the program state and exclusively "read-only" operations
(or <span class="emphasis"><em>queries</em></span>) should be used to program contracts.
</p><p>
This library enforces this constraint at compile-time using C++ <code class="computeroutput"><span class="keyword">const</span></code> qualifier. <sup>[<a name="contract__.contract_programming_overview.constant_correctness.f0" href="#ftn.contract__.contract_programming_overview.constant_correctness.f0" class="footnote">11</a>]</sup> Contracts only have access to the object, function arguments,
and function return value via constant references <code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span></code> or pointers <code class="computeroutput"><span class="keyword">const</span><span class="special">*</span></code>. Other variables (static data members, global
variables, etc) can be explicitly made constant using <span class="emphasis"><em>constant
assertions</em></span> (see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section).
</p></div><div class="section" title="Specification vs. Implementation"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.specification_vs__implementation"></a><a class="link" href="#contract__.contract_programming_overview.specification_vs__implementation" title="Specification vs. Implementation">Specification
vs. Implementation</a></h3></div></div></div><p>
Contracts are part of the program specification and not of its implementation.
Therefore, contracts should appear within C++ declarations and not within
definitions. <sup>[<a name="contract__.contract_programming_overview.specification_vs__implementation.f0" href="#ftn.contract__.contract_programming_overview.specification_vs__implementation.f0" class="footnote">12</a>]</sup>
</p><p>
Contracts are most useful when they assert conditions only using public members.
For example, the caller of a member function cannot in general make sure
that the member function preconditions are satisfied if these preconditions
use private members that are not accessible by the caller. Therefore, a failure
in the preconditions will not necessarily indicate a bug in the caller given
that the caller was not able to fully check the preconditions before calling
the member function. In most cases, the need of using non-public members
to check contracts indicates an error in the design of the class. However,
given that C++ provides programmers ways around access level restrictions
(e.g., <code class="computeroutput"><span class="keyword">friend</span></code> and function pointers),
this library leaves it up to the programmers to make sure that only public
members are used in contract assertions (<a class="link" href="#N1962_anchor">[N1962]</a>
follows the same approach not forcing contracts to only use public members,
<a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
instead generates a compiler error if preconditions use non-public members).
<sup>[<a name="contract__.contract_programming_overview.specification_vs__implementation.f1" href="#ftn.contract__.contract_programming_overview.specification_vs__implementation.f1" class="footnote">13</a>]</sup>
</p><p>
Finally, only public member functions shall check class invariants. Private
and protected member functions are allowed to brake class invariants because
private and protected member are part of the class implementation and not
of its specification.
</p></div><div class="section" title="Broken Contracts"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.broken_contracts"></a><a class="link" href="#contract__.contract_programming_overview.broken_contracts" title="Broken Contracts">Broken
Contracts</a></h3></div></div></div><p>
After programmers specify contracts, this library automatically checks preconditions,
postconditions, class invariants, block invariants, and loop variants at
run-time. If a precondition, postcondition, class invariant, block invariants,
or loop variant is checked to be false or throws an exception then the library
invokes the <code class="computeroutput"><a class="link" href="#contract.precondition_broken" title="Function precondition_broken">contract::precondition_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.postcondition_broken" title="Function postcondition_broken">contract::postcondition_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.class_invariant_b_id485392" title="Function class_invariant_broken_on_entry">contract::class_invariant_broken_on_entry</a></code>
or <code class="computeroutput"><a class="link" href="#contract.class_invariant_b_id485470" title="Function class_invariant_broken_on_exit">contract::class_invariant_broken_on_exit</a></code>
or <code class="computeroutput"><a class="link" href="#contract.class_invariant_b_id485548" title="Function class_invariant_broken_on_throw">contract::class_invariant_broken_on_throw</a></code>,
<code class="computeroutput"><a class="link" href="#contract.block_invariant_broken" title="Function block_invariant_broken">contract::block_invariant_broken</a></code>,
and <code class="computeroutput"><a class="link" href="#contract.loop_variant_broken" title="Function loop_variant_broken">contract::loop_variant_broken</a></code>
function respectively.
</p><p>
These function invoke <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span><span class="special">()</span></code> by default but programmers can redefine
them to take a different action (throw an exception, exit the program, etc)
using <code class="computeroutput"><a class="link" href="#contract.set_precondition_broken">contract::set_precondition_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.set_postcondition_broken">contract::set_postcondition_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.set_class_invariant_broken">contract::set_class_invariant_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.set_block_invariant_broken">contract::set_block_invariant_broken</a></code>,
and <code class="computeroutput"><a class="link" href="#contract.set_loop_variant_broken">contract::set_loop_variant_broken</a></code>
(this mechanism is similar to the one of C++'s <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span><span class="special">()</span></code>). See the <a class="link" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_" title="Contract Broken Handlers (Throw on Failure)">Contract
Broken Handlers</a> section for an example.
</p></div><div class="section" title="Features"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.contract_programming_overview.features"></a><a class="link" href="#contract__.contract_programming_overview.features" title="Features">Features</a></h3></div></div></div><p>
The design of this library was largely based on <a class="link" href="#N1962_anchor">[N1962]</a>
and on the <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
programming language as specified by <a class="link" href="#Meyer97_anchor">[Meyer97]</a>.
The following table compares features between this library, the proposal
for adding Contract Programming to the C++ standard <a class="link" href="#N1962_anchor">[N1962]</a>,
the <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
programming language <a class="link" href="#Meyer97_anchor">[Meyer97]</a>, and
the <a class="ulink" href="http://dlang.org" target="_top">D</a> programming language <a class="link" href="#Bright04_anchor">[Bright04]</a>.
</p><div class="informaltable"><table border="1"><colgroup><col><col><col><col><col></colgroup><thead><tr><th>
<p>
Feature
</p>
</th><th>
<p>
This Library (C++03)
</p>
</th><th>
<p>
[N1962] Proposal (not part of C++)
</p>
</th><th>
<p>
ISE Eiffel 5.4
</p>
</th><th>
<p>
D
</p>
</th></tr></thead><tbody><tr><td>
<p>
<span class="emphasis"><em>Keywords and Specifiers</em></span>
</p>
</td><td>
<p>
<code class="computeroutput"><span class="identifier">precondition</span></code>,
<code class="computeroutput"><span class="identifier">postcondition</span></code>,
<code class="computeroutput"><span class="identifier">extends</span></code>, <code class="computeroutput"><span class="identifier">initialize</span></code>, <code class="computeroutput"><span class="identifier">requires</span></code>,
<code class="computeroutput"><span class="identifier">in</span></code>, <code class="computeroutput"><span class="identifier">out</span></code>, <code class="computeroutput"><span class="identifier">deduce</span></code>,
<code class="computeroutput"><span class="identifier">comma</span></code> (these are
specifiers and not keywords, they have special meaning only in
specific positions within the declarations passed to this library
macros)
</p>
</td><td>
<p>
<code class="computeroutput"><span class="identifier">invariant</span></code>, <code class="computeroutput"><span class="identifier">precondition</span></code>, <code class="computeroutput"><span class="identifier">postcondition</span></code>,
<code class="computeroutput"><span class="identifier">oldof</span></code>
</p>
</td><td>
<p>
<code class="literal">invariant</code>, <code class="literal">require</code>, <code class="literal">ensure</code>,
<code class="literal">do</code>, <code class="literal">require else</code>, <code class="literal">ensure
then</code>, <code class="literal">old</code>, <code class="literal">result</code>,
<code class="literal">variant</code>
</p>
</td><td>
<p>
<code class="literal">invariant</code>, <code class="literal">in</code>, <code class="literal">out</code>,
<code class="literal">assert</code>, <code class="literal">static</code>
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>On contract failure</em></span>
</p>
</td><td>
<p>
Default to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span><span class="special">()</span></code> (but can be customized to exit,
abort, throw exceptions, etc).
</p>
</td><td>
<p>
Default to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span><span class="special">()</span></code> (but can be customized to exit,
abort, throw exceptions, etc).
</p>
</td><td>
<p>
Throw exceptions
</p>
</td><td>
<p>
Throw exceptions
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Result value in postconditions</em></span>
</p>
</td><td>
<p>
Yes, <code class="computeroutput"><span class="keyword">auto</span> </code><code class="literal"><span class="emphasis"><em>result-variable-name</em></span></code><code class="computeroutput">
<span class="special">=</span> <span class="keyword">return</span></code>.
</p>
</td><td>
<p>
Yes, <code class="computeroutput"><span class="identifier">postcondition</span> <span class="special">(</span></code><code class="literal"><span class="emphasis"><em>result-variable-name</em></span></code><code class="computeroutput"><span class="special">)</span></code>.
</p>
</td><td>
<p>
Yes, <code class="literal">result</code> keyword.
</p>
</td><td>
<p>
No.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Old values in postconditions</em></span>
</p>
</td><td>
<p>
Yes, <code class="computeroutput"><span class="keyword">auto</span> </code><code class="literal"><span class="emphasis"><em>old-variable-name</em></span></code><code class="computeroutput">
<span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span>
</code><code class="literal"><span class="emphasis"><em>oldof-expression</em></span></code>.
</p>
</td><td>
<p>
Yes, <code class="computeroutput"><span class="identifier">oldof</span> </code><code class="literal"><span class="emphasis"><em>oldof-expression</em></span></code>.
</p>
</td><td>
<p>
Yes, <code class="literal">old <span class="emphasis"><em>old-expression</em></span></code>.
</p>
</td><td>
<p>
No.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Subcontracting</em></span>
</p>
</td><td>
<p>
Yes, also support multiple base contracts for multiple inheritance
(can force preconditions to be specified only by base classes using
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS" title="Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS">CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</a></code>).
</p>
</td><td>
<p>
Yes, also support multiple base contracts but only base classes
can specify preconditions.
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
Yes.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Contracts for pure virtual functions</em></span>
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
Yes (contracts for abstract functions).
</p>
</td><td>
<p>
No (but planned).
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Arbitrary code in contracts</em></span>
</p>
</td><td>
<p>
No, assertions only.
</p>
</td><td>
<p>
No, assertions only.
</p>
</td><td>
<p>
No, assertions only plus preconditions can only access public members.
</p>
</td><td>
<p>
Yes.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Constant-correct</em></span>
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
No.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Function code ordering</em></span>
</p>
</td><td>
<p>
Preconditions, postconditions, body.
</p>
</td><td>
<p>
Preconditions, postconditions, body.
</p>
</td><td>
<p>
Preconditions, body, postconditions.
</p>
</td><td>
<p>
Preconditions, postconditions, body.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Static assertions</em></span>
</p>
</td><td>
<p>
Yes, can use <code class="computeroutput"><span class="identifier">static_assert</span></code>
(internally implemented using <code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT_MSG</span></code>,
no <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
required).
</p>
</td><td>
<p>
Yes, can use <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
<code class="computeroutput"><span class="identifier">static_assert</span></code>.
</p>
</td><td>
<p>
No.
</p>
</td><td>
<p>
Yes.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Block invariants</em></span>
</p>
</td><td>
<p>
Yes, <code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT" title="Macro CONTRACT_BLOCK_INVARIANT">CONTRACT_BLOCK_INVARIANT</a></code>.
</p>
</td><td>
<p>
Yes, <code class="computeroutput"><span class="identifier">invariant</span></code>.
</p>
</td><td>
<p>
Yes (<code class="computeroutput"><span class="identifier">check</span></code> instruction
and loop invariants).
</p>
</td><td>
<p>
No (just <code class="computeroutput"><span class="identifier">assert</span></code>).
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Loop variants</em></span>
</p>
</td><td>
<p>
Yes, <code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT" title="Macro CONTRACT_LOOP_VARIANT">CONTRACT_LOOP_VARIANT</a></code>.
</p>
</td><td>
<p>
No.
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
No.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Disable assertion checking within assertions checking</em></span>
</p>
</td><td>
<p>
Yes (use <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION" title="Macro CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION">CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION</a></code>
for preconditions to disable no assertion). Use <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_THREAD_SAFE" title="Macro CONTRACT_CONFIG_THREAD_SAFE">CONTRACT_CONFIG_THREAD_SAFE</a></code>
to make the implementation of this feature thread-safe in multi-threaded
programs (but it will introduce a global lock).
</p>
</td><td>
<p>
Yes for class invariants and postconditions but preconditions disable
no assertion.
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
No.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Assertion requirements</em></span>
</p>
</td><td>
<p>
Yes (compilation and run-time checking of single assertions can
be disabled when specific assertion requirements are not met).
</p>
</td><td>
<p>
No.
</p>
</td><td>
<p>
No (but all types are <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/CopyConstructible.html" target="_top"><code class="literal">CopyConstructible</code></a>,
<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/Assignable.html" target="_top"><code class="literal">Assignable</code></a>,
and <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>
in <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
so there is not a real need for this).
</p>
</td><td>
<p>
No.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Nested member function calls</em></span>
</p>
</td><td>
<p>
Disable nothing. <sup>[<a name="contract__.contract_programming_overview.features.f0" href="#ftn.contract__.contract_programming_overview.features.f0" class="footnote">a</a>]</sup>
</p>
</td><td>
<p>
Disable nothing.
</p>
</td><td>
<p>
Disable all checks.
</p>
</td><td>
<p>
Disable nothing.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Non-static class invariants checking</em></span>
</p>
</td><td>
<p>
At constructor exit, at destructor entry, and at public member
function entry, exit, and on throw (but only if programmers declare
these functions using this library macros). Same for volatile class
invariants.
</p>
</td><td>
<p>
At constructor exit, at destructor entry, and at public member
function entry, exit, and on throw (volatile class invariants not
supported).
</p>
</td><td>
<p>
At constructor exit, and around public member functions.
</p>
</td><td>
<p>
At constructor exit, at destructor entry, an around public member
functions.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Static class invariants checking</em></span>
</p>
</td><td>
<p>
At entry and exit of any (also static) member function, constructor,
and destructor.
</p>
</td><td>
<p>
No.
</p>
</td><td>
<p>
No (but <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
does not have static members).
</p>
</td><td>
<p>
No.
</p>
</td></tr><tr><td>
<p>
<span class="emphasis"><em>Removable from object code</em></span>
</p>
</td><td>
<p>
Yes, using any combination of <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_BLOCK_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_BLOCK_INVARIANTS">CONTRACT_CONFIG_NO_BLOCK_INVARIANTS</a></code>,
and <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_LOOP_VARIANTS" title="Macro CONTRACT_CONFIG_NO_LOOP_VARIANTS">CONTRACT_CONFIG_NO_LOOP_VARIANTS</a></code>.
</p>
</td><td>
<p>
Yes.
</p>
</td><td>
<p>
Yes (but predefined combinations only).
</p>
</td><td>
<p>
Yes.
</p>
</td></tr></tbody><tbody class="footnotes"><tr><td colspan="5"><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.features.f0" href="#contract__.contract_programming_overview.features.f0" class="para">a</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Older versions of
this library automatically defined a data member used to disable
checking of class invariants within member function calls. However,
this feature, which was required by older revisions of <a class="link" href="#N1962_anchor">[N1962]</a>, is no longer required
by <a class="link" href="#N1962_anchor">[N1962]</a>, it complicates
the implementation, and in multi-thread programs would introduce
a lock that synchronizes all member functions calls for a given
object so it was removed in the current revision of the library.
</p></div></td></tr></tbody></table></div><p>
Contract Programming is also provided by the following references.
</p><div class="informaltable"><table border="1"><colgroup><col><col><col></colgroup><thead><tr><th>
<p>
Reference
</p>
</th><th>
<p>
Language
</p>
</th><th>
<p>
Notes
</p>
</th></tr></thead><tbody><tr><td>
<p>
<a class="link" href="#Bright04b_anchor">[Bright04b]</a>
</p>
</td><td>
<p>
C++
</p>
</td><td>
<p>
The Digital Mars C++ compiler extends C++ adding Contract Programming
language support (among many other features).
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Lindrud04_anchor">[Lindrud04]</a>
</p>
</td><td>
<p>
C++
</p>
</td><td>
<p>
This supports class invariants and old values but it does not support
subcontracting, contracts are specified within definitions instead
of declarations, assertions are not constant-correct (unfortunately,
these missing features are all essential to Contract Programming).
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Tandin04_anchor">[Tandin04]</a>
</p>
</td><td>
<p>
C++
</p>
</td><td>
<p>
Interestingly, these contract macros automatically generate <a class="ulink" href="http://www.doxygen.org" target="_top">Doxygen</a> documentation <sup>[<a name="contract__.contract_programming_overview.features.f1" href="#ftn.contract__.contract_programming_overview.features.f1" class="footnote">a</a>]</sup> but old values, class invariants, and subcontracting
are not supported plus contracts are specified within definitions
instead of declarations (unfortunately, these missing features
are all essential to Contract Programming).
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Maley99_anchor">[Maley99]</a>
</p>
</td><td>
<p>
C++
</p>
</td><td>
<p>
This supports Contract Programming including subcontracting but
with some limitations (e.g., programmers need to manually build
an inheritance tree using artificial template parameters), it does
not use macros so programmers are required to write by hand a significant
amount of boiler-plate code. (The authors have found this work
very inspiring when they started to develop this library.)
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#C2_anchor">[C2]</a>
</p>
</td><td>
<p>
C++
</p>
</td><td>
<p>
This uses an external preprocessing tool (the authors could no
longer find this project code-base to evaluate it).
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#iContract_anchor">[iContract]</a>
</p>
</td><td>
<p>
Java
</p>
</td><td>
<p>
This uses an external preprocessing tool.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Jcontract_anchor">[Jcontract]</a>
</p>
</td><td>
<p>
Java
</p>
</td><td>
<p>
This uses an external preprocessing tool.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#CodeContracts_anchor">[CodeContracts]</a>
</p>
</td><td>
<p>
.NET
</p>
</td><td>
<p>
Microsoft Contract Programming for .NET programming languages.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#SpecSharp_anchor">[SpecSharp]</a>
</p>
</td><td>
<p>
C#
</p>
</td><td>
<p>
This is a C# extension with Contract Programming language support.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Chrome02_anchor">[Chrome02]</a>
</p>
</td><td>
<p>
Object Pascal
</p>
</td><td>
<p>
This is the .NET version of Object Pascal and it has language support
for Contract Programming.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#SPARKAda_anchor">[SPARKAda]</a>
</p>
</td><td>
<p>
Ada
</p>
</td><td>
<p>
This is an Ada-like programming language with Contract Programming
support.
</p>
</td></tr></tbody><tbody class="footnotes"><tr><td colspan="3"><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.features.f1" href="#contract__.contract_programming_overview.features.f1" class="para">a</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Older versions of
this library used to automatically generate <a class="ulink" href="http://www.doxygen.org" target="_top">Doxygen</a>
documentation from the contract macros. This functionality was
abandoned for a number of reasons: this library macros became
too complex and the <a class="ulink" href="http://www.doxygen.org" target="_top">Doxygen</a>
preprocessor is no longer able to expand them; the <a class="ulink" href="http://www.doxygen.org" target="_top">Doxygen</a>
documentation was just a repeat of the contract code (so programmers
can directly look at contracts in the header files), <a class="ulink" href="http://www.doxygen.org" target="_top">Doxygen</a>
might not necessarily be the documentation tool chosen by all
programmers.
</p></div></td></tr></tbody></table></div><p>
Typically, preprocessing tools external to the language work by transforming
specially formatted code comments into contract code that is then checked
at run-time. One of this library primary goals was to support Contract Programming
entirely within C++ and without using any tool external to the standard language
(C++ macros were used instead of external preprocessing tools).
</p><p>
To the authors' knowledge, this the only library that fully support Contract
Programming for C++ (see the <a class="link" href="#contract__.bibliography" title="Bibliography">Bibliography</a>
section for the complete list of Contract Programming references studied
by the authors).
</p></div></div><div class="section" title="Tutorial"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.tutorial"></a><a class="link" href="#contract__.tutorial" title="Tutorial">Tutorial</a></h2></div></div></div><p>
This section explains how to program contracts using this library. See the
<a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section for a complete guide
on this library syntax.
</p><div class="section" title="Free Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.free_functions"></a><a class="link" href="#contract__.tutorial.free_functions" title="Free Functions">Free Functions</a></h3></div></div></div><p>
Consider the following free function <code class="computeroutput"><span class="identifier">postinc</span></code>
which performs a post-increment on its parameter (see also <a class="ulink" href="../../example/contracts/no_contract_postinc.cpp" target="_top"><code class="literal">no_contract_postinc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">int</span> <span class="keyword">const</span> <span class="identifier">postinc</span> <span class="special">(</span> <span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="comment">// precondition: value &lt; std::numeric_limits&lt;int&gt;::max()</span>
<span class="comment">// postcondition: value == oldof value + 1</span>
<span class="comment">// result == oldof valule</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span><span class="special">++;</span>
<span class="special">}</span>
</pre><p>
</p><p>
Let's now program the function declaration using the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
macro but without programming the contract yet (see also <a class="ulink" href="../../example/contracts/no_pre_post_postinc.cpp" target="_top"><code class="literal">no_pre_post_postinc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Declare free function (for programming contracts).</span>
<span class="keyword">int</span> <span class="keyword">const</span> <span class="special">(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">int</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span> <span class="comment">// Non-fundamental types in `()`.</span>
<span class="comment">// precondition: value &lt; std::numeric_limits&lt;int&gt;::max()</span>
<span class="comment">// postcondition: value == oldof value + 1</span>
<span class="comment">// result == oldof value</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span><span class="special">++;</span>
<span class="special">}</span>
</pre><p>
</p><p>
All necessary header files for this library are included by <code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
(see also the <a class="link" href="#contract__.getting_started" title="Getting Started">Getting Started</a>
section).
</p><p>
The function body is programmed outside the library macro. Therefore, while
this library alters the function declaration syntax, it does not change the
syntax used to implement the function.
</p><p>
The function name <code class="computeroutput"><span class="special">(</span><span class="identifier">postinc</span><span class="special">)</span></code> must always be wrapped within parenthesis
so it can be passed to this library macros.
</p><p>
The function result and parameter types must be wrapped within parenthesis
unless they are fundamental types containing no symbol (symbols are tokens
different from the alphanumeric tokens <code class="computeroutput"><span class="identifier">a</span><span class="special">-</span><span class="identifier">z</span></code>, <code class="computeroutput"><span class="identifier">A</span><span class="special">-</span><span class="identifier">Z</span></code>,
<code class="computeroutput"><span class="number">0</span><span class="special">-</span><span class="number">9</span></code>). In this example, the result type <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
is a fundamental type and it contains no symbol so the parenthesis around
it <code class="computeroutput"><span class="special">(</span><span class="keyword">int</span>
<span class="keyword">const</span><span class="special">)</span></code>
are allowed but not required. <sup>[<a name="contract__.tutorial.free_functions.f0" href="#ftn.contract__.tutorial.free_functions.f0" class="footnote">14</a>]</sup> Instead, the parameter type <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code> is a fundamental type but it contains
the reference symbol <code class="computeroutput"><span class="special">&amp;</span></code> so
it must be wrapped within parenthesis <code class="computeroutput"><span class="special">(</span><span class="keyword">int</span><span class="special">&amp;)</span></code>.
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
In general, every token which is not a known keyword (<code class="computeroutput"><span class="keyword">int</span></code>
is a known keyword but the function name is not) or that contains a non-alphanumeric
symbol (e.g., <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>)
must be wrapped within round parenthesis <code class="computeroutput"><span class="special">(...)</span></code>
unless it is the very last token of a given syntactic element (e.g., the
function parameter name <code class="computeroutput"><span class="identifier">value</span></code>
is the last token of the parameter declaration). <sup>[<a name="contract__.tutorial.free_functions.f1" href="#ftn.contract__.tutorial.free_functions.f1" class="footnote">15</a>]</sup>
</p><p>
See the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section for more
information.
</p></td></tr></table></div><p>
Each function parameter must always specify both its type and its name (parameter
names can instead by omitted in usual C++ declarations). <sup>[<a name="contract__.tutorial.free_functions.f2" href="#ftn.contract__.tutorial.free_functions.f2" class="footnote">16</a>]</sup> As usual, additional parameters can be specified separated by
commas <code class="computeroutput"><span class="special">,</span></code> on compilers that support
variadic macros (these include most modern compilers, MSVC, GCC, and all
<a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a> compilers,
see the <a class="link" href="#contract__.no_variadic_macros" title="No Variadic Macros">No Variadic Macros</a>
section for compilers that do not support variadic macros). The configuration
macro <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_FUNCTION_ARITY_MAX" title="Macro CONTRACT_CONFIG_FUNCTION_ARITY_MAX">CONTRACT_CONFIG_FUNCTION_ARITY_MAX</a></code>
indicates the maximum number of function parameters that can be specified.
An empty parameter list must be specified using <code class="computeroutput"><span class="keyword">void</span></code>
(this is similar to the usual C++ syntax that allows to declare a function
with no parameter using <code class="literal"><span class="emphasis"><em>result-type function-name </em></span></code><code class="computeroutput"><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span></code>).
<sup>[<a name="contract__.tutorial.free_functions.f3" href="#ftn.contract__.tutorial.free_functions.f3" class="footnote">17</a>]</sup> Default parameter values can be specified using <code class="computeroutput"><span class="special">,</span> <span class="keyword">default</span> </code><code class="literal"><span class="emphasis"><em>default-value</em></span></code>
immediately following the parameter name. The storage classifiers <code class="computeroutput"><span class="keyword">auto</span></code> and <code class="computeroutput"><span class="keyword">register</span></code>
can be specified as usual as part of the parameter type. <sup>[<a name="contract__.tutorial.free_functions.f4" href="#ftn.contract__.tutorial.free_functions.f4" class="footnote">18</a>]</sup> Functions can be overloaded by specifying different parameter
types and they can recursively call themselves as usual.
</p><p>
For example, the following function <code class="computeroutput"><span class="identifier">postinc</span></code>
is overloaded to work on <code class="computeroutput"><span class="keyword">long</span></code>
instead of <code class="computeroutput"><span class="keyword">int</span></code> numbers, it is
implemented using recursion, it increments the specified number by <code class="computeroutput"><span class="identifier">offset</span></code> which is stored into a register
variable and it has a default value of <code class="computeroutput"><span class="number">1</span></code>
(see also <a class="ulink" href="../../example/contracts/params_postinc.cpp" target="_top"><code class="literal">params_postinc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Overload, storage classifiers, and default parameters.</span>
<span class="keyword">long</span> <span class="keyword">const</span> <span class="special">(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">long</span><span class="special">&amp;)</span> <span class="identifier">value</span><span class="special">,</span> <span class="keyword">register</span> <span class="keyword">unsigned</span> <span class="identifier">offset</span><span class="special">,</span> <span class="keyword">default</span> <span class="number">1</span> <span class="special">)</span>
<span class="comment">// precondition: value &lt; std::numeric_limits&lt;long&gt;::max()</span>
<span class="comment">// postcondition: value == oldof value + 1</span>
<span class="comment">// result == oldof value</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">long</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">value</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">offset</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">value</span> <span class="special">+=</span> <span class="number">1</span><span class="special">;</span>
<span class="identifier">postinc</span><span class="special">(</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">offset</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span> <span class="comment">// Recursive calls.</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="keyword">long</span> <span class="identifier">value</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">postinc</span><span class="special">(</span><span class="identifier">value</span><span class="special">)</span> <span class="special">==</span> <span class="number">1</span><span class="special">);</span> <span class="comment">// Increment of 1 (it is 1).</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">postinc</span><span class="special">(</span><span class="identifier">value</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span> <span class="special">==</span> <span class="number">2</span><span class="special">);</span> <span class="comment">// Increment of 4 (it is 2).</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">value</span> <span class="special">==</span> <span class="number">6</span><span class="special">);</span> <span class="comment">// Incremented of 4 (it was 2).</span>
</pre><p>
</p><p>
Function and array types cannot be directly used as function parameter types
within the contract macros but extra <code class="computeroutput"><span class="keyword">typedef</span></code>
declarations can be used to workaround this limitation (for multi-dimensional
arrays, the maximum number of supported array dimensions is specified by
the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_ARRAY_DIMENSION_MAX" title="Macro CONTRACT_CONFIG_ARRAY_DIMENSION_MAX">CONTRACT_CONFIG_ARRAY_DIMENSION_MAX</a></code>
macro). For example (see also <a class="ulink" href="../../example/contracts/params_funcptr_array_apply.cpp" target="_top"><code class="literal">params_funcptr_array_apply.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="comment">// Contracts cannot directly use array type syntax, use via `typedef` instead.</span>
<span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">array2x3</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">];</span>
<span class="keyword">typedef</span> <span class="keyword">int</span> <span class="special">(*</span><span class="identifier">funcptr</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="special">);</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">apply</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">funcptr</span><span class="special">)</span> <span class="identifier">f</span><span class="special">,</span> <span class="special">(</span><span class="identifier">array2x3</span><span class="special">)</span> <span class="identifier">m</span> <span class="special">)</span>
<span class="comment">// precondition: f != NULL</span>
<span class="comment">// m != NULL</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">for</span> <span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">2</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="keyword">for</span> <span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">j</span> <span class="special">&lt;</span> <span class="number">3</span><span class="special">;</span> <span class="special">++</span><span class="identifier">j</span><span class="special">)</span>
<span class="identifier">m</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="identifier">j</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">m</span><span class="special">[</span><span class="identifier">i</span><span class="special">][</span><span class="identifier">j</span><span class="special">]);</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">offset</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">i</span> <span class="special">+</span> <span class="number">10</span><span class="special">;</span> <span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">x</span><span class="special">[</span><span class="number">2</span><span class="special">][</span><span class="number">3</span><span class="special">]</span> <span class="special">=</span> <span class="special">{</span>
<span class="special">{</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">,</span> <span class="number">3</span><span class="special">},</span>
<span class="special">{</span><span class="number">4</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="number">6</span><span class="special">}</span>
<span class="special">};</span>
<span class="identifier">apply</span><span class="special">(</span><span class="identifier">offset</span><span class="special">,</span> <span class="identifier">x</span><span class="special">);</span>
</pre><p>
</p><p>
Spaces and new-lines make no syntactical difference and they can be used
freely within this library macros. <sup>[<a name="contract__.tutorial.free_functions.f5" href="#ftn.contract__.tutorial.free_functions.f5" class="footnote">19</a>]</sup> The following aesthetic conventions are followed in this documentation
(because the authors think they improve readability):
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Round parenthesis are spaced when a list of tokens is expected (e.g.,
the function parameter list): <code class="computeroutput"><span class="special">(</span>
</code><code class="literal"><span class="emphasis"><em>token1</em></span></code><code class="computeroutput"> <span class="special">)</span></code>,
<code class="computeroutput"><span class="special">(</span> </code><code class="literal"><span class="emphasis"><em>token1</em></span></code><code class="computeroutput"><span class="special">,</span> </code><code class="literal"><span class="emphasis"><em>token2</em></span></code><code class="computeroutput">
<span class="special">)</span></code>, <code class="computeroutput"><span class="special">(</span>
</code><code class="literal"><span class="emphasis"><em>token1</em></span></code><code class="computeroutput"><span class="special">,</span>
</code><code class="literal"><span class="emphasis"><em>token2</em></span></code><code class="computeroutput"><span class="special">,</span>
</code><code class="literal"><span class="emphasis"><em>token3</em></span></code><code class="computeroutput"> <span class="special">)</span></code>,
etc.
</li><li class="listitem">
Round parenthesis are not spaced when only a single token is expected
(e.g., the function name): <code class="computeroutput"><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>token</em></span></code><code class="computeroutput"><span class="special">)</span></code>.
</li></ol></div></div><div class="section" title="Preconditions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.preconditions"></a><a class="link" href="#contract__.tutorial.preconditions" title="Preconditions">Preconditions</a></h3></div></div></div><p>
Let's program the preconditions of <code class="computeroutput"><span class="identifier">postinc</span></code>
(see also <a class="ulink" href="../../example/contracts/pre_only_postinc.cpp" target="_top"><code class="literal">pre_only_postinc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="keyword">const</span> <span class="special">(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">int</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">value</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// Precondition.</span>
<span class="comment">// postcondition: value == oldof value + 1</span>
<span class="comment">// result == oldof value</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span><span class="special">++;</span>
<span class="special">}</span>
</pre><p>
</p><p>
In this example, the preconditions assert only one boolean condition but
additional boolean conditions can be listed separated by commas <code class="computeroutput"><span class="special">,</span></code>. Preconditions are automatically checked
by the library when the <code class="computeroutput"><span class="identifier">postinc</span></code>
function is called, immediately before the body is executed (i.e., at function
<span class="emphasis"><em>entry</em></span>). See also the <a class="link" href="#contract__.contract_programming_overview.free_function_calls" title="Free Function Calls">Free
Function Calls</a> section.
</p><p>
Contracts are supposed to check but not to modify the state of the program
(see the <a class="link" href="#contract__.contract_programming_overview.constant_correctness" title="Constant-Correctness">Constant-Correctness</a>
section). Therefore, this library evaluates all contract conditions in constant-correct
context. Specifically, in this example the type of <code class="computeroutput"><span class="identifier">value</span></code>
type is automatically promoted from <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code> to <code class="computeroutput"><span class="keyword">int</span>
<span class="keyword">const</span><span class="special">&amp;</span></code>
within the preconditions and an attempt to modify <code class="computeroutput"><span class="identifier">value</span></code>
within the preconditions will correctly generate a compile-time error.
</p></div><div class="section" title="Postconditions (Result and Old Values)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.postconditions__result_and_old_values_"></a><a class="link" href="#contract__.tutorial.postconditions__result_and_old_values_" title="Postconditions (Result and Old Values)">Postconditions
(Result and Old Values)</a></h3></div></div></div><p>
Let's program the postconditions of <code class="computeroutput"><span class="identifier">postinc</span></code>
completing the contract (see also <a class="ulink" href="../../example/contracts/post_also_postinc.cpp" target="_top"><code class="literal">post_also_postinc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="keyword">const</span> <span class="special">(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">int</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">value</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="comment">// Postconditions.</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="comment">// Result value.</span>
<span class="keyword">auto</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span><span class="special">,</span> <span class="comment">// Old value(s).</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="comment">// Assertion(s)...</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">old_value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span><span class="special">++;</span>
<span class="special">}</span>
</pre><p>
</p><p>
Postconditions are automatically checked by the library when the <code class="computeroutput"><span class="identifier">postinc</span></code> function is called, immediately
after the body is executed but only if the body does not throw an exception
(i.e., at function <span class="emphasis"><em>normal exit</em></span>). See also the <a class="link" href="#contract__.contract_programming_overview.free_function_calls" title="Free Function Calls">Free
Function Calls</a> section.
</p><p>
Postconditions can access the function return value by declaring a variable
of type <code class="computeroutput"><span class="keyword">auto</span></code> <sup>[<a name="contract__.tutorial.postconditions__result_and_old_values_.f0" href="#ftn.contract__.tutorial.postconditions__result_and_old_values_.f0" class="footnote">20</a>]</sup> and assigning it to the <code class="computeroutput"><span class="keyword">return</span></code>
keyword (the variable name is arbitrary but <code class="computeroutput"><span class="identifier">result</span></code>
is often used).
</p><p>
Postconditions can also access the <span class="emphasis"><em>old value</em></span> that an
expression had just before the body was executed. This is done by declaring
a variable of type <code class="computeroutput"><span class="keyword">auto</span></code> and
assigning it to <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code>
<code class="literal"><span class="emphasis"><em>expression</em></span></code> (the variable name is
arbitrary but the <code class="computeroutput"><span class="identifier">old_</span></code> prefix
is often used). Before executing the function body, the library automatically
copies (once) the value of the specified expression into a variable with
the specified name which is then made available to the postconditions. Therefore,
the type of an old value expression must have a copy constructor (or, more
precisely, it must be be <a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies"><code class="literal">ConstantCopyConstructible</code></a>),
otherwise the library will generate a compile-time error. The parenthesis
around the expression passed to the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code>
macro are allowed but not required (in this example, <code class="computeroutput"><span class="identifier">CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">value</span><span class="special">)</span></code> could have been equivalently used instead
of <code class="computeroutput"><span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span></code>
but the latter was preferred because of lesser parenthesis). In this sense,
the syntax of the <code class="computeroutput"><span class="identifier">CONTRACT_OLDOF</span></code>
macro resembles the syntax of the <code class="computeroutput"><span class="keyword">sizeof</span></code>
operator which also allows but does not require parenthesis when applied
to value expressions (i.e., <code class="computeroutput"><span class="keyword">sizeof</span>
<span class="identifier">value</span></code> and <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">value</span><span class="special">)</span></code> are both valid). <sup>[<a name="contract__.tutorial.postconditions__result_and_old_values_.f1" href="#ftn.contract__.tutorial.postconditions__result_and_old_values_.f1" class="footnote">21</a>]</sup> (The maximum number of supported and possible old value declarations
is specified by the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_OLDOF_MAX" title="Macro CONTRACT_CONFIG_OLDOF_MAX">CONTRACT_CONFIG_OLDOF_MAX</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_OLDOFS" title="Macro CONTRACT_LIMIT_OLDOFS">CONTRACT_LIMIT_OLDOFS</a></code>
macros respectively.)
</p><p>
Postconditions always access result and old values in constant-correct context
so that contracts cannot modify the state of the program (see the <a class="link" href="#contract__.contract_programming_overview.constant_correctness" title="Constant-Correctness">Constant-Correctness</a>
section).
</p><p>
In general, it is recommended to specify multiple assertions separated by
commas and not group them together into a single condition using the operator
<code class="computeroutput"><span class="keyword">and</span></code> (or <code class="computeroutput"><span class="special">&amp;&amp;</span></code>).
This is because if assertion conditions are programmed together using <code class="computeroutput"><span class="keyword">and</span></code> then it will not be clear which assertion
condition actually failed in case the contract is broken. For example, if
in the code above we programmed one single postcondition <code class="computeroutput"><span class="special">(</span><span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span> <span class="keyword">and</span>
<span class="special">(</span><span class="identifier">result</span>
<span class="special">==</span> <span class="identifier">old_value</span><span class="special">)</span></code> then in case the postcondition failed we
would not know which condition failed <code class="computeroutput"><span class="identifier">value</span>
<span class="special">==</span> <span class="identifier">old_value</span>
<span class="special">+</span> <span class="number">1</span></code>
or <code class="computeroutput"><span class="identifier">result</span> <span class="special">==</span>
<span class="identifier">old_value</span></code>.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
All tokens must be specified in the fixed order listed in the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section (it is not possible to specify postconditions before preconditions,
<code class="computeroutput"><span class="keyword">volatile</span></code> before <code class="computeroutput"><span class="keyword">const</span></code> for member functions, etc). <sup>[<a name="contract__.tutorial.postconditions__result_and_old_values_.f2" href="#ftn.contract__.tutorial.postconditions__result_and_old_values_.f2" class="footnote">22</a>]</sup>
</p></td></tr></table></div></div><div class="section" title="Classes and Class Invariants"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.classes_and_class_invariants"></a><a class="link" href="#contract__.tutorial.classes_and_class_invariants" title="Classes and Class Invariants">Classes
and Class Invariants</a></h3></div></div></div><p>
Consider the following class <code class="computeroutput"><span class="identifier">ivector</span></code>
which is a vector of integers with a constructor, destructor, and the <code class="computeroutput"><span class="identifier">push_back</span></code> member function (see also <a class="ulink" href="../../example/contracts/no_contract_ivector.cpp" target="_top"><code class="literal">no_contract_ivector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">class</span> <span class="identifier">ivector</span>
<span class="special">{</span>
<span class="comment">// invariant: empty() == (size() == 0)</span>
<span class="comment">// size() &lt;= capacity()</span>
<span class="comment">// capacity() &lt;= max_size()</span>
<span class="comment">// std::distance(begin(), end()) == int(size())</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">ivector</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="comment">// precondition: count &gt;= 0</span>
<span class="comment">// postcondition: size() == count</span>
<span class="comment">// boost::algorithm::all_of_equal(begin(), end(), 0)</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">ivector</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</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="keyword">int</span> <span class="keyword">const</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="comment">// precondition: size() &lt; max_size()</span>
<span class="comment">// postcondition: size() == oldof size() + 1</span>
<span class="comment">// capacity() &gt;= oldof capacity()</span>
<span class="comment">// back() == value</span>
<span class="special">{</span>
<span class="identifier">vector_</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="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vector_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p><p>
Let's program the class declaration and the class invariants using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> and <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code>
macros respectively (see also <a class="ulink" href="../../example/contracts/class_ivector.cpp" target="_top"><code class="literal">class_ivector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Declare the class.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">ivector</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="comment">// Specify the class invariants.</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">(),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
A class must always be declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>
macro in oder to later be able to program contracts for its constructors,
destructor, and member functions. Similarly to function names, the class
name must always be wrapped within parenthesis <code class="computeroutput"><span class="special">(</span><span class="identifier">ivector</span><span class="special">)</span></code>
(because the class name is not a known keyword and it is not the last element
of the class declaration syntax as base classes and other elements can be
specified). Only constructors, destructors, and member functions that are
public check the class invariants while the ones that are either protected
or private do not (see the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract
Programming Overview</a> section). The class invariant must always be
specified for a class declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>
macro and it must appear at the very beginning of the class definition (no
statement can precede the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code>
macro, not even a <code class="computeroutput"><span class="keyword">typedef</span></code> or
a <code class="computeroutput"><span class="keyword">friend</span></code> declaration). If a
class has no class invariant, the class invariants must be specified <code class="computeroutput"><span class="keyword">void</span></code>:
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">ivector</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// No class invariant.</span>
<span class="comment">// ...</span>
</pre><p>
Using the same macro, this library also allows to specify contracts for
<code class="computeroutput"><span class="keyword">struct</span></code>: <sup>[<a name="contract__.tutorial.classes_and_class_invariants.f0" href="#ftn.contract__.tutorial.classes_and_class_invariants.f0" class="footnote">23</a>]</sup>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">ivector</span><span class="special">)</span> <span class="comment">// Structs with contracts.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// ...</span>
</pre><p>
The usual differences between <code class="computeroutput"><span class="keyword">struct</span></code>
and <code class="computeroutput"><span class="keyword">class</span></code> also apply when this
library is used (i.e., default member and inheritance access levels are
<code class="computeroutput"><span class="keyword">public</span></code> for <code class="computeroutput"><span class="keyword">struct</span></code>
and <code class="computeroutput"><span class="keyword">private</span></code> for <code class="computeroutput"><span class="keyword">class</span></code>).
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
Unfortunately, this library does not allow to specify contracts for <code class="computeroutput"><span class="keyword">union</span></code>. <sup>[<a name="contract__.tutorial.classes_and_class_invariants.f1" href="#ftn.contract__.tutorial.classes_and_class_invariants.f1" class="footnote">24</a>]</sup>
</p></td></tr></table></div><p>
No contracts are checked (not event the class invariants) when a data member
is accessed directly so it might be best for both classes and structs to
have no non-constant public data member (but access all data members via
appropriate member functions that can check the class and sturct contracts).
</p></div><div class="section" title="Constructors"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.constructors"></a><a class="link" href="#contract__.tutorial.constructors" title="Constructors">Constructors</a></h3></div></div></div><p>
Let's program the <code class="computeroutput"><span class="identifier">ivector</span></code>
class constructor and its contract using the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code>
macro (see also <a class="ulink" href="../../example/contracts/class_ivector.cpp" target="_top"><code class="literal">class_ivector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Declare the constructor and its contract.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">ivector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="number">0</span><span class="special">)</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
</pre><p>
</p><p>
Constructor, destructor, and member function declarations must always repeat
their access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> <sup>[<a name="contract__.tutorial.constructors.f0" href="#ftn.contract__.tutorial.constructors.f0" class="footnote">25</a>]</sup> which is specified without the usual trailing column symbol
<code class="computeroutput"><span class="special">:</span></code>. (This use of <code class="computeroutput"><span class="keyword">public</span></code>, <code class="computeroutput"><span class="keyword">protected</span></code>,
and <code class="computeroutput"><span class="keyword">private</span></code> resembles <a class="ulink" href="http://en.wikipedia.org/wiki/Java_(programming_language)" target="_top">Java</a>'s
syntax.)
</p><p>
The constructor name <code class="computeroutput"><span class="special">(</span><span class="identifier">ivector</span><span class="special">)</span></code> and the non-fundamental parameter type
<code class="computeroutput"><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span></code> must be wrapped within parenthesis (because
they are not known keywords and they are not at the end of a syntactic element).
</p><p>
Member initializers are programed as a comma-separated list but using the
specifier <code class="literal">initialize( <span class="emphasis"><em>expression1</em></span>, <span class="emphasis"><em>expression2</em></span>,
... )</code> instead of the usual column symbol <code class="literal">: <span class="emphasis"><em>expression1</em></span>,
<span class="emphasis"><em>expression2</em></span>, ...</code>. When specified, they must
appear at the very end of constructor declarations (after both preconditions
and postcondition if present). <sup>[<a name="contract__.tutorial.constructors.f1" href="#ftn.contract__.tutorial.constructors.f1" class="footnote">26</a>]</sup> Unfortunately, when member initializers are specified, the constructor
body must be defined together with its declaration and contract (see the
<a class="link" href="#contract__.tutorial.forward_declarations_and_body_definitions" title="Forward Declarations and Body Definitions">Forward
Declarations and Body Definitions</a> section).
</p><p>
There is no object before the constructor body is executed, therefore this
library will generate a compile-time error if either preconditions or postcondition
old value expressions try to access the object <code class="computeroutput"><span class="keyword">this</span></code>.
For the same reason, only static class invariants are checked at entry of
public constructors (non-static class invariants are checked at public constructor
normal exit but not at entry). Finally, preconditions are checked before
member initializers are executed (so the initializers can rely on preconditions
for validating constructor arguments). See also the <a class="link" href="#contract__.contract_programming_overview.constructor_calls" title="Constructor Calls">Constructor
Calls</a> section.
</p></div><div class="section" title="Destructors"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.destructors"></a><a class="link" href="#contract__.tutorial.destructors" title="Destructors">Destructors</a></h3></div></div></div><p>
Let's program the <code class="computeroutput"><span class="identifier">ivector</span></code>
class destructor using the <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code>
macro (see also <a class="ulink" href="../../example/contracts/class_ivector.cpp" target="_top"><code class="literal">class_ivector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Declare the destructor (so it checks invariants).</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">ivector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
</pre><p>
</p><p>
The destructor access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> must always be specified. The destructor
name <code class="computeroutput"><span class="special">(~</span><span class="identifier">ivector</span><span class="special">)</span></code> must be wrapped within parenthesis. The
destructor empty parameter list must be specified using <code class="computeroutput"><span class="keyword">void</span></code>
(same as for constructors, member functions, and free functions with no parameters).
</p><p>
Destructors have no parameter and there is no object after the destructor
body is executed. Therefore, destructors cannot specify neither preconditions
nor postconditions. <sup>[<a name="contract__.tutorial.destructors.f0" href="#ftn.contract__.tutorial.destructors.f0" class="footnote">27</a>]</sup> However, it is still necessary to ontract (at least public) destructors
so they check static and non-static class invariants at entry, and non-static
class invariants at exit. See also the <a class="link" href="#contract__.contract_programming_overview.destructor_calls" title="Destructor Calls">Destructor
Calls</a> section.
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
Only members declared using this library macros check the class invariants.
Therefore, at least all public members of a class with non-empty class
invariants should be declared using this library macros even when they
have no preconditions and no postconditions so that they check the class
invariants (that is the case for public destructors).
</p></td></tr></table></div><p>
In general, there is no need to use this library macros to declare free functions,
constructors, destructors, and member function only when:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
A free function has no preconditions and no postconditions.
</li><li class="listitem">
A private or protected constructor, destructor, or member function has
no preconditions and no postconditions (regardless of class invariants
because private and protected members never check class invariants).
</li><li class="listitem">
A public constructor, destructor, or member function has no preconditions,
no postconditions, and its class has no class invariants.
</li></ol></div></div><div class="section" title="Member Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.member_functions"></a><a class="link" href="#contract__.tutorial.member_functions" title="Member Functions">Member Functions</a></h3></div></div></div><p>
Let's program the member function <code class="computeroutput"><span class="identifier">ivector</span><span class="special">::</span><span class="identifier">push_back</span></code>
and its contract using the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
macro (see also <a class="ulink" href="../../example/contracts/class_ivector.cpp" target="_top"><code class="literal">class_ivector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Declare the member function with its contract.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</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="identifier">vector_</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>
</pre><p>
</p><p>
The member function access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> must always be specified. The member
function name <code class="computeroutput"><span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span></code> must be wrapped within parenthesis. The
member function result type <code class="computeroutput"><span class="keyword">void</span></code>
and parameter type <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
can but do not have to be wrapped within parenthesis (because they are both
fundamental types containing no symbol).
</p><p>
Public non-static member functions check static and non-static class invariants
at both entry and exit. Preconditions are checked at entry and postconditions
are checked at normal exit. Both preconditions and postconditions can access
the object and the member function parameters in constant-correct context.
Postconditions can declare return and old value variables (again, in contract-correct
context). See also the <a class="link" href="#contract__.contract_programming_overview.member_function_calls" title="Member Function Calls">Member
Function Calls</a> section.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
Contracts are most useful when the assertions only use public members that
are accessible from the caller so the caller can properly verify and use
the contract. In particular, preconditions of a member function or constructor
that use non-public members are essentially incorrect because they cannot
be verified by the caller before calling the function (in fact, <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
generates a compile-time error in this case).
</p><p>
This library leave it up to programmers to only use public members when
programming contracts and especially when programming preconditions (see
the <a class="link" href="#contract__.contract_programming_overview.specification_vs__implementation" title="Specification vs. Implementation">Specification
vs. Implementation</a> section).
</p></td></tr></table></div></div><div class="section" title="Inheritance and Subcontracting"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.inheritance_and_subcontracting"></a><a class="link" href="#contract__.tutorial.inheritance_and_subcontracting" title="Inheritance and Subcontracting">Inheritance
and Subcontracting</a></h3></div></div></div><p>
Consider the following class <code class="computeroutput"><span class="identifier">unique_identifiers</span></code>
which is a collection of unique integral identifiers (see also <a class="ulink" href="../../example/contracts/subcontract_identifiers.cpp" target="_top"><code class="literal">subcontract_identifiers.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">unique_identifiers</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">unique_identifiers</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">unique_identifiers</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">add</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">id</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="comment">// Id not already present.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_found</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="comment">// If id was not already present, it was added now...</span>
<span class="identifier">old_found</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="comment">// ...and size was increased of 1.</span>
<span class="identifier">old_found</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">identifiers_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">id</span><span class="special">);</span>
<span class="special">}</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
Reading the contracts we can understand the semantics of the class operation
(even if we do not consult the class implementation):
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
The collection is constructed with zero size as specified by the constructor
postconditions. Consistently, the class invariants assert that the class
size must never be negative (but it can be zero).
</li><li class="listitem">
The member function <code class="computeroutput"><span class="identifier">unique_identifiers</span><span class="special">::</span><span class="identifier">add</span></code>
allows to add an integral identifier to the collection. The preconditions
assert that the specified identifier must not already be part of the
collection making sure that duplicate identifiers are never added.
</li><li class="listitem">
If the specified identifier was not already part of the collection (<code class="computeroutput"><span class="identifier">old_found</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>)
then the postconditions assert that the identifier is added and consequently
that the size of the collection increased by one. Note that both postconditions
are trivially <code class="computeroutput"><span class="keyword">true</span></code> if instead
the identifier was already part of the collection (<code class="computeroutput"><span class="identifier">old_found</span></code>
is <code class="computeroutput"><span class="keyword">true</span></code>). We call these
type of assertions that are "guarded" by an activation condition
<span class="emphasis"><em>select assertions</em></span> (here we have used the C++ ternary
operator <code class="computeroutput"><span class="special">?:</span></code> to program select
assertions, the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced Topics</a>
section will introduce an alternative construct for select assertions).
</li></ol></div><p>
Let's assume that we want to derive from <code class="computeroutput"><span class="identifier">unique_identifiers</span></code>
another type of collection <code class="computeroutput"><span class="identifier">duplicate_identifiers</span></code>
which instead allows to add duplicate identifiers (see also <a class="ulink" href="../../example/contracts/subcontract_identifiers.cpp" target="_top"><code class="literal">subcontract_identifiers.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">duplicate_identifiers</span><span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">unique_identifiers</span> <span class="special">)</span> <span class="comment">// Automatically subcontract.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">1</span> <span class="comment">// Strengthened inherited class invariants (in `and`).</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">duplicate_identifiers</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">id</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">1</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// As usual, constructor should not call virtual member `add`.</span>
<span class="identifier">identifiers_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">id</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">duplicate_identifiers</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">add</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">id</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="comment">// Wakened inherited preconditions (in `or`).</span>
<span class="comment">// OK even if id is already present.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="comment">// Strengthened inherited postconditions (in `and`).</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_found</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="comment">// Inherited postconditions not checked because of</span>
<span class="comment">// select assertions, plus size unchanged if already present.</span>
<span class="identifier">old_found</span> <span class="special">?</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">:</span> <span class="keyword">true</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">())</span> <span class="special">{</span> <span class="comment">// Not already present.</span>
<span class="comment">// Unfortunately, must invoke base function via `BODY` macro.</span>
<span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">unique_identifiers</span><span class="special">,</span> <span class="identifier">add</span><span class="special">)(</span><span class="identifier">id</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">};</span>
</pre><p>
</p><p>
The derived class <code class="computeroutput"><span class="identifier">duplicate_identifiers</span></code>
publicly inherits from the base class <code class="computeroutput"><span class="identifier">unique_identifiers</span></code>
using the specifier <code class="literal">extends( <span class="emphasis"><em>base1</em></span>, <span class="emphasis"><em>base2</em></span>,
... )</code> instead of the usual column symbol <code class="literal">: <span class="emphasis"><em>base1</em></span>,
<span class="emphasis"><em>base2</em></span>, ...</code>. (This use of <code class="computeroutput"><span class="identifier">extends</span></code>
resembles <a class="ulink" href="http://en.wikipedia.org/wiki/Java_(programming_language)" target="_top">Java</a>'s
syntax.) As usual, the inheritance access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> is optional and it defaults to <code class="computeroutput"><span class="keyword">public</span></code> for <code class="computeroutput"><span class="keyword">struct</span></code>
and to <code class="computeroutput"><span class="keyword">private</span></code> for <code class="computeroutput"><span class="keyword">class</span></code>. Virtual base classes can also be specified
but <code class="computeroutput"><span class="keyword">virtual</span></code> must always be specified
after the inheritance access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> if present. Multiple base classes
(<code class="computeroutput"><span class="identifier">base1</span></code>, <code class="computeroutput"><span class="identifier">base2</span></code>,
etc) can be specified for multiple-inheritance (the configuration macro
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_INHERITANCE_MAX" title="Macro CONTRACT_CONFIG_INHERITANCE_MAX">CONTRACT_CONFIG_INHERITANCE_MAX</a></code>
indicates the maximum number of base classes that can be specified).
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
This library automatically subcontracts the derived class when one or more
base classes are specified (see the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract
Programming Overview</a> section).
</p></td></tr></table></div><p>
Let's assume that a <code class="computeroutput"><span class="identifier">duplicate_identifers</span></code>
object is constructed with identifier <code class="computeroutput"><span class="number">123</span></code>
and that we try to add the identifier <code class="computeroutput"><span class="number">123</span></code>
again:
</p><p>
</p><pre class="programlisting"><span class="identifier">duplicate_identifiers</span> <span class="identifier">ids</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">ids</span><span class="special">.</span><span class="identifier">add</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
</pre><p>
</p><p>
Reading both the derived and base class contracts, we can understand the
semantics of the derived class operation (even if we do not consult the base
and derived class implementations):
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
The <code class="computeroutput"><span class="identifier">duplicate_identifiers</span></code>
constructor creates a collection with size one as specified by the constructor
postconditions. Therefore, the <code class="computeroutput"><span class="identifier">duplicate_identifiers</span></code>
class invariants assert that size is always positive. Subcontracting
automatically checks the <code class="computeroutput"><span class="identifier">unique_identifiers</span></code>
base class invariants in <a class="link" href="#logic_and_anchor">logic-and</a>
with the <code class="computeroutput"><span class="identifier">duplicate_identifiers</span></code>
derived class invariants thus class invariants can only be strengthened
by derived classes (this is necessary because the derived class can be
used whenever the base class is used therefore the derived class must
satisfy the base class invariants at all times, see also the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a> and the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract
Programming Overview</a> section).
</li><li class="listitem">
Subcontracting automatically checks the <code class="computeroutput"><span class="identifier">unique_identifiers</span><span class="special">::</span><span class="identifier">add</span></code>
overridden preconditions in <a class="link" href="#logic_or_anchor">logic-or</a>
with the <code class="computeroutput"><span class="identifier">duplicate_identifiers</span><span class="special">::</span><span class="identifier">add</span></code>
overriding preconditions thus preconditions can only be weakened by overriding
member functions (this is necessary because the overriding member function
can be called under the conditions for which the overridden function
is called, see also the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a> and the <a class="link" href="#contract__.contract_programming_overview.member_function_calls" title="Member Function Calls">Member
Function Calls</a> section). Indeed, in this example the <code class="computeroutput"><span class="identifier">unique_identifiers</span><span class="special">::</span><span class="identifier">add</span></code> preconditions fail (because <code class="computeroutput"><span class="number">123</span></code> is already in the collection) but the
<code class="computeroutput"><span class="identifier">derived_identifiers</span><span class="special">::</span><span class="identifier">add</span></code> preconditions pass so the <a class="link" href="#logic_or_anchor">logic-or</a> of the two sets of preconditions
passes and the call <code class="computeroutput"><span class="identifier">ids</span><span class="special">.</span><span class="identifier">add</span><span class="special">(</span><span class="number">123</span><span class="special">)</span></code>
is a valid call.
</li><li class="listitem">
Subcontracting automatically checks the <code class="computeroutput"><span class="identifier">unique_identifiers</span><span class="special">::</span><span class="identifier">add</span></code>
overridden postconditions in <a class="link" href="#logic_and_anchor">logic-and</a>
with the <code class="computeroutput"><span class="identifier">duplicate_identifiers</span><span class="special">::</span><span class="identifier">add</span></code>
overriding postconditions thus postconditions can only be strengthen
by overriding member functions (this is necessary because the overriding
function can be called in any context in which the overridden function
is called, see also the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a> and the <a class="link" href="#contract__.contract_programming_overview.member_function_calls" title="Member Function Calls">Member
Function Calls</a> section). Indeed, in this example the <code class="computeroutput"><span class="identifier">unique_identifiers</span><span class="special">::</span><span class="identifier">add</span></code> postconditions pass because the
identifier <code class="computeroutput"><span class="number">123</span></code> was already
added (<code class="computeroutput"><span class="identifier">old_found</span></code> is
<code class="computeroutput"><span class="keyword">true</span></code>) and <code class="computeroutput"><span class="identifier">unique_identifiers</span><span class="special">::</span><span class="identifier">add</span></code> select assertions trivially return
<code class="computeroutput"><span class="keyword">true</span></code>. The <code class="computeroutput"><span class="identifier">duplicate_identifiers</span><span class="special">::</span><span class="identifier">add</span></code> postconditions are then checked
in <a class="link" href="#logic_and_anchor">logic-and</a> and they correctly
assert that the collection size did not change given that <code class="computeroutput"><span class="number">123</span></code> was already added. Therefore, the call
<code class="computeroutput"><span class="identifier">ids</span><span class="special">.</span><span class="identifier">add</span><span class="special">(</span><span class="number">123</span><span class="special">)</span></code> is
valid but adds no identifier.
</li></ol></div><p>
Finally, note that within the body of overriding functions it is necessary
to use the <code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code>
macro to call the overridden function as in <code class="computeroutput"><span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">unique_identifiers</span><span class="special">,</span> <span class="identifier">add</span><span class="special">)(</span><span class="identifier">id</span><span class="special">)</span></code>.
</p><div class="warning" title="Warning"><table border="0" summary="Warning"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../doc/src/images/warning.png"></td><th align="left">Warning</th></tr><tr><td align="left" valign="top"><p>
Unfortunately, invoking the overridden function from within the overriding
function body without using <code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code>
results in infinite recursion. <sup>[<a name="contract__.tutorial.inheritance_and_subcontracting.f0" href="#ftn.contract__.tutorial.inheritance_and_subcontracting.f0" class="footnote">28</a>]</sup> This limitation might be removed in future revisions of this
library (see also <a class="ulink" href="https://sourceforge.net/apps/trac/contractpp/ticket/46" target="_top">Ticket
46</a>).
</p></td></tr></table></div></div><div class="section" title="Class Templates"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.class_templates"></a><a class="link" href="#contract__.tutorial.class_templates" title="Class Templates">Class Templates</a></h3></div></div></div><p>
Let's program a class template <code class="computeroutput"><span class="identifier">vector</span></code>
similar to the class <code class="computeroutput"><span class="identifier">ivector</span></code>
we have seen before but that works on a generic value type <code class="computeroutput"><span class="identifier">T</span></code> and not just on <code class="computeroutput"><span class="keyword">int</span></code>
(see also <a class="ulink" href="../../example/contracts/class_template_vector.cpp" target="_top"><code class="literal">class_template_vector.cpp</code></a> and
<a class="ulink" href="../../example/contracts/pushable.hpp" target="_top"><code class="literal">pushable.hpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="string">"pushable.hpp"</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span> <span class="comment">// Subcontract.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Within templates, use contract macros postfixed by `_TPL`.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">(),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span> <span class="identifier">const_iterator</span><span class="special">;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">T</span><span class="special">())</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span>
<span class="comment">// Overridden postconditions also check `back() == value`.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</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><p>
(The specifications of the code in this example are not fully programmed,
in particular concepts, see the <a class="link" href="#contract__.concepts" title="Concepts">Concepts</a>
section, and assertion requirements, see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section, have been omitted for simplicity.)
</p><p>
Note that templates are declared using the specifier <code class="computeroutput"><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="special">...</span>
<span class="special">)</span></code> which uses round parenthesis instead
of the usual angular parenthesis <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="special">...</span>
<span class="special">&gt;</span></code>. However, after a template is
declared using round parenthesis, angular parenthesis are used as usual to
instantiate the template (e.g., the base class <code class="computeroutput"><span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>).
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
Within a type-dependent scope (e.g., within the class template of the above
example) the special macros with the <code class="computeroutput"><span class="identifier">_TPL</span></code>
postfix must be used instead of the macros we have seen so far. <sup>[<a name="contract__.tutorial.class_templates.f0" href="#ftn.contract__.tutorial.class_templates.f0" class="footnote">29</a>]</sup> (The same applies to function templates, see below.)
</p></td></tr></table></div><p>
In the example above, the enclosing class template <code class="computeroutput"><span class="identifier">vector</span></code>
is not declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_TPL" title="Macro CONTRACT_CLASS_TPL">CONTRACT_CLASS_TPL</a></code>
macro because its enclosing scope is not type-dependent (it is the global
namespace). Within such a class template however, all contract macros must
use the <code class="computeroutput"><span class="identifier">_TPL</span></code> postfix so
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT_TPL" title="Macro CONTRACT_CLASS_INVARIANT_TPL">CONTRACT_CLASS_INVARIANT_TPL</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_TPL" title="Macro CONTRACT_CONSTRUCTOR_TPL">CONTRACT_CONSTRUCTOR_TPL</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_TPL" title="Macro CONTRACT_DESTRUCTOR_TPL">CONTRACT_DESTRUCTOR_TPL</a></code>,
and <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION_TPL" title="Macro CONTRACT_FUNCTION_TPL">CONTRACT_FUNCTION_TPL</a></code>
must be used to specify class invariants, declare constructors, declare the
destructor, and declare member functions respectively. In general, the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_TPL" title="Macro CONTRACT_CLASS_TPL">CONTRACT_CLASS_TPL</a></code> macro is used when
declaring a class nested within a class template (see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section).
</p><p>
This libraries supports all the different kinds of template parameters that
C++ supports: type template parameters, value template parameters, and template
template parameters.
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
Type template parameters can be prefixed by either <code class="computeroutput"><span class="keyword">typename</span></code>
or <code class="computeroutput"><span class="keyword">class</span></code> as usual, <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">A</span></code>
or <code class="computeroutput"><span class="keyword">class</span> <span class="identifier">C</span></code>.
</li><li class="listitem">
The type of value template parameters must be wrapped within parenthesis
<code class="computeroutput"><span class="special">(</span><span class="identifier">A</span><span class="special">)</span> <span class="identifier">D</span></code>
but the parenthesis are optional for fundamental types that contain no
symbol <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">B</span></code>.
</li><li class="listitem">
Template template parameters use round parenthesis for their template
specifier but then their inner template parameters are specified using
the usual C++ syntax <code class="computeroutput"><span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">X</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span>
<span class="special">...</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">Y</span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span> <span class="keyword">class</span> <span class="identifier">E</span></code>.
</li></ul></div><p>
Default template parameters are specified using <code class="computeroutput"><span class="special">,</span>
<span class="keyword">default</span> </code><code class="literal"><span class="emphasis"><em>default-value</em></span></code>
right after the template parameter declaration. For example (see also <a class="ulink" href="../../example/contracts/template_params.cpp" target="_top"><code class="literal">template_params.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Class template parameters.</span>
<span class="keyword">template</span><span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">A</span> <span class="comment">// Type template parameter.</span>
<span class="special">,</span> <span class="keyword">int</span> <span class="identifier">B</span> <span class="comment">// Value template parameter.</span>
<span class="special">,</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">A</span> <span class="comment">// Optional type template parameter.</span>
<span class="special">,</span> <span class="special">(</span><span class="identifier">A</span><span class="special">)</span> <span class="identifier">D</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">B</span> <span class="comment">// Optional value template parameter.</span>
<span class="special">,</span> <span class="keyword">template</span><span class="special">(</span> <span class="comment">// Template template parameter: Outer template</span>
<span class="keyword">typename</span> <span class="identifier">X</span> <span class="comment">// uses `()` but rest uses usual syntax.</span>
<span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">S</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">=</span> <span class="identifier">S</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">Y</span>
<span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Z</span> <span class="special">=</span> <span class="keyword">int</span>
<span class="special">,</span> <span class="identifier">Z</span> <span class="identifier">V</span> <span class="special">=</span> <span class="number">0</span>
<span class="special">)</span> <span class="keyword">class</span> <span class="identifier">E</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">x</span> <span class="comment">// Optional template template parameter.</span>
<span class="special">)</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">a</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
Finally, the syntax <code class="computeroutput"><span class="keyword">template</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span></code>
is used instead of the usual <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span> <span class="special">&gt;</span></code>
to specify a template with no template parameters (this is typically used
for template specializations, see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section).
</p></div><div class="section" title="Function Templates"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.function_templates"></a><a class="link" href="#contract__.tutorial.function_templates" title="Function Templates">Function Templates</a></h3></div></div></div><p>
Let's program a function template <code class="computeroutput"><span class="identifier">postinc</span></code>
similar to the function <code class="computeroutput"><span class="identifier">postinc</span></code>
that we have seen before but that works on a generic type <code class="computeroutput"><span class="identifier">T</span></code>
and not just on <code class="computeroutput"><span class="keyword">int</span></code> (see also
<a class="ulink" href="../../example/contracts/function_template_postinc.cpp" target="_top"><code class="literal">function_template_postinc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="comment">// Template parameter(s).</span>
<span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">)</span> <span class="special">(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">value</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span><span class="special">,</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">old_value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span><span class="special">++;</span>
<span class="special">}</span>
</pre><p>
</p><p>
(The specifications of the code in this example are not fully programmed,
in particular concepts, see the <a class="link" href="#contract__.concepts" title="Concepts">Concepts</a>
section, and assertion requirements, see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section, have been omitted for simplicity.)
</p><p>
Type, value, and template template parameters are specified for function
templates using the same syntax used for class template parameters, for example
(see also <a class="ulink" href="../../example/contracts/template_params.cpp" target="_top"><code class="literal">template_params.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Function template parameters.</span>
<span class="keyword">template</span><span class="special">(</span> <span class="comment">// As usual, no default template parameters allowed in functions.</span>
<span class="keyword">typename</span> <span class="identifier">A</span> <span class="comment">// Type template parameter.</span>
<span class="special">,</span> <span class="keyword">int</span> <span class="identifier">B</span> <span class="comment">// Value template parameter.</span>
<span class="special">,</span> <span class="keyword">class</span> <span class="identifier">C</span> <span class="comment">// Type template parameter.</span>
<span class="special">,</span> <span class="special">(</span><span class="identifier">A</span><span class="special">)</span> <span class="identifier">D</span> <span class="comment">// Value template parameter.</span>
<span class="special">,</span> <span class="keyword">template</span><span class="special">(</span> <span class="comment">// Template template parameter: Outer template</span>
<span class="keyword">typename</span> <span class="identifier">X</span> <span class="comment">// uses `()` but rest uses usual syntax.</span>
<span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">S</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">=</span> <span class="identifier">S</span> <span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">Y</span>
<span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Z</span> <span class="special">=</span> <span class="keyword">int</span>
<span class="special">,</span> <span class="identifier">Z</span> <span class="identifier">V</span> <span class="special">=</span> <span class="number">0</span>
<span class="special">)</span> <span class="keyword">class</span> <span class="identifier">E</span>
<span class="special">)</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
Note that as usual, function templates cannot have default template parameters
in <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>.
</p></div><div class="section" title="Forward Declarations and Body Definitions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.tutorial.forward_declarations_and_body_definitions"></a><a class="link" href="#contract__.tutorial.forward_declarations_and_body_definitions" title="Forward Declarations and Body Definitions">Forward
Declarations and Body Definitions</a></h3></div></div></div><p>
This library supports contracts for classes and functions that have forward
declarations. Furthermore, the function body definition can be deferred and
separated from the function declaration and its contracts. For example (see
also <a class="ulink" href="../../example/contracts/body_natural.hpp" target="_top"><code class="literal">body_natural.hpp</code></a>,
<a class="ulink" href="../../example/contracts/body_natural_impl.hpp" target="_top"><code class="literal">body_natural_impl.hpp</code></a>,
and <a class="ulink" href="../../example/contracts/body_natural.cpp" target="_top"><code class="literal">body_natural.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">Default</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">()</span> <span class="special">&gt;</span> <span class="comment">// Class forward declaration.</span>
<span class="keyword">class</span> <span class="identifier">natural</span> <span class="special">;</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="comment">// Function forward declaration.</span>
<span class="keyword">bool</span> <span class="identifier">less</span> <span class="special">(</span> <span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">left</span><span class="special">,</span> <span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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">bool</span> <span class="special">(</span><span class="identifier">greater</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span> <span class="special">(</span><span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">?</span> <span class="keyword">not</span> <span class="identifier">less</span><span class="special">(</span><span class="identifier">left</span><span class="special">,</span> <span class="identifier">right</span><span class="special">)</span> <span class="special">:</span> <span class="keyword">true</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred free function body definition, use `;`.</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Class declaration (with contracts).</span>
<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="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="identifier">Default</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">natural</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">get</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">natural</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">Default</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">value</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">get</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="comment">// Unfortunately, no member initializers when body deferred.</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred constructor body definition, use `;`.</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(~</span><span class="identifier">natural</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred destructor body definition, use `;`.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">equal</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">natural</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="keyword">not</span> <span class="identifier">less</span><span class="special">(*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">right</span><span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="keyword">not</span> <span class="identifier">greater</span><span class="special">(*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">right</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred member function body definition, use `;`.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">get</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Function declaration (with contracts).</span>
<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">bool</span> <span class="special">(</span><span class="identifier">less</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span> <span class="special">(</span><span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">?</span> <span class="keyword">not</span> <span class="identifier">greater</span><span class="special">(</span><span class="identifier">left</span><span class="special">,</span> <span class="identifier">right</span><span class="special">)</span> <span class="special">:</span> <span class="keyword">true</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">get</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p><p>
In this example, the class <code class="computeroutput"><span class="identifier">natural</span></code>
and the function <code class="computeroutput"><span class="identifier">less</span></code> are
first forward declared and later declared. Note that the contracts can be
specified only once and together with the class or function declaration (not
with the forward declarations that can be many).
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
This library forces to specify contracts with the function and class declarations
and not with their definitions. This is correct because contracts are part
of the program specifications (declarations) and not of the program implementation
(definitions), see also the <a class="link" href="#contract__.contract_programming_overview.specification_vs__implementation" title="Specification vs. Implementation">Specification
vs. Implementation</a> section.
</p></td></tr></table></div><p>
Note that as usual in C++, not all functions need to be defined when they
are first declared. In this example, <code class="computeroutput"><span class="identifier">less</span></code>
and <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">get</span></code> are defined together with their declarations
and contracts while the other function bodies are defined separately.
</p><p>
The definitions of the free function <code class="computeroutput"><span class="identifier">greater</span></code>,
the constructor <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">natural</span></code>, the destructor <code class="computeroutput"><span class="identifier">natural</span><span class="special">::~</span><span class="identifier">natural</span></code>,
and the member function <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">equal</span></code>
are deferred and separated from their declarations and contracts. In fact,
a semicolon <code class="computeroutput"><span class="special">;</span></code> is specified right
after the contract declaration macros instead of programming the function
bodies. As usual in C++, the semicolon <code class="computeroutput"><span class="special">;</span></code>
indicates that the function body definition is deferred and it will appear
at some other point in the program (often in a <code class="literal">.cpp</code> file
that can be compiled separately). In this example, the deferred functions
are templates or template members therefore the definitions where programmed
in a header file that must be made available when the template declarations
are compiled (see also <a class="ulink" href="../../example/contracts/body_natural_impl.hpp" target="_top"><code class="literal">body_natural_impl.hpp</code></a>):
<sup>[<a name="contract__.tutorial.forward_declarations_and_body_definitions.f0" href="#ftn.contract__.tutorial.forward_declarations_and_body_definitions.f0" class="footnote">30</a>]</sup>
</p><p>
</p><pre class="programlisting"><span class="comment">// Deferred body definitions, separated from their declarations and contracts.</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">CONTRACT_FREE_BODY</span><span class="special">(</span><span class="identifier">greater</span><span class="special">)(</span>
<span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">left</span><span class="special">,</span> <span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span> <span class="special">&gt;</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">get</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">Default</span> <span class="special">&gt;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">((</span><span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Default</span><span class="special">&gt;),</span> <span class="identifier">natural</span><span class="special">)(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">value_</span> <span class="special">=</span> <span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">Default</span> <span class="special">&gt;</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">((</span><span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Default</span><span class="special">&gt;),</span> <span class="special">~</span><span class="identifier">natural</span><span class="special">)(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// Do nothing.</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">Default</span> <span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">((</span><span class="identifier">natural</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Default</span><span class="special">&gt;),</span> <span class="identifier">equal</span><span class="special">)(</span>
<span class="identifier">natural</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="keyword">not</span> <span class="identifier">less</span><span class="special">(*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">right</span><span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="keyword">not</span> <span class="identifier">greater</span><span class="special">(*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">right</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
</p><p>
The usual C++ syntax is used to define the bodies (in fact this library only
alters the syntax of class and function declarations but not the syntax of
their definitions). However, free function, constructor, destructor, and
member function names must be specified using the macros <code class="computeroutput"><a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_BODY" title="Macro CONTRACT_CONSTRUCTOR_BODY">CONTRACT_CONSTRUCTOR_BODY</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_BODY" title="Macro CONTRACT_DESTRUCTOR_BODY">CONTRACT_DESTRUCTOR_BODY</a></code>,
and <code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code>
respectively. <sup>[<a name="contract__.tutorial.forward_declarations_and_body_definitions.f1" href="#ftn.contract__.tutorial.forward_declarations_and_body_definitions.f1" class="footnote">31</a>]</sup> The free body macro takes one parameter which is the function
name. The other body macros take two parameters that are the fully qualified
class type (including eventual template parameters as usual) and the constructor,
destructor, or member function name. <sup>[<a name="contract__.tutorial.forward_declarations_and_body_definitions.f2" href="#ftn.contract__.tutorial.forward_declarations_and_body_definitions.f2" class="footnote">32</a>]</sup> The class type must be wrapped within extra parenthesis like
in this example but only if it contains multiple template parameters (because
these use unwrapped commas which cannot be passed within macro parameters,
see the beginning of the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section).
</p><p>
In this example, it was possible to separate the constructor body definition
because the constructor did not specify member initializers.
</p><div class="warning" title="Warning"><table border="0" summary="Warning"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../doc/src/images/warning.png"></td><th align="left">Warning</th></tr><tr><td align="left" valign="top"><p>
Unfortunately, when member initializers are specified, the macro <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_BODY" title="Macro CONTRACT_CONSTRUCTOR_BODY">CONTRACT_CONSTRUCTOR_BODY</a></code> cannot
be used, the constructor body definition cannot be deferred, and the constructor
body must be defined together with the constructor declaration and its
contract inside the class definition. <sup>[<a name="contract__.tutorial.forward_declarations_and_body_definitions.f3" href="#ftn.contract__.tutorial.forward_declarations_and_body_definitions.f3" class="footnote">33</a>]</sup>
</p></td></tr></table></div></div></div><div class="section" title="Advanced Topics"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.advanced_topics"></a><a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced Topics</a></h2></div></div></div><p>
This section explains advanced usages of this library in programming contracts.
See the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section for a complete
guide on this library syntax.
</p><div class="section" title="Commas and Leading Symbols in Macros"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.commas_and_leading_symbols_in_macros"></a><a class="link" href="#contract__.advanced_topics.commas_and_leading_symbols_in_macros" title="Commas and Leading Symbols in Macros">Commas
and Leading Symbols in Macros</a></h3></div></div></div><p>
C++ macros cannot correctly parse a macro parameter if it contains a comma
<code class="computeroutput"><span class="special">,</span></code> that is not wrapped within
round parenthesis <code class="computeroutput"><span class="special">()</span></code> (because
the preprocessor interprets such a comma as separation between two distinct
macro parameters instead that as part of one single macro parameter, see
also <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>).
Furthermore, syntactic elements specified to this library macros cannot start
with a non-alphanumeric symbol (<code class="computeroutput"><span class="special">-</span><span class="number">1</span></code>, <code class="computeroutput"><span class="number">1.23</span></code>,
<code class="computeroutput"><span class="string">"abc"</span></code>, <code class="computeroutput"><span class="special">::</span></code>, etc). <sup>[<a name="contract__.advanced_topics.commas_and_leading_symbols_in_macros.f0" href="#ftn.contract__.advanced_topics.commas_and_leading_symbols_in_macros.f0" class="footnote">34</a>]</sup> For example, the parameter type <code class="computeroutput"><span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span></code> cannot be passed to this library for
two reasons: It starts with the non-alphanumeric symbol <code class="computeroutput"><span class="special">::</span></code>
and it contains the comma <code class="computeroutput"><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span></code>
which is not wrapped by round parenthesis.
</p><p>
The <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>
macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span></code>
can be used as usual to overcome this issue. However, using the <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span></code> macro presents two
limitations: It makes the syntax of this library macros more cumbersome and,
more importantly, it does not allow C++ to automatically deduce function
template parameters (see <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>
for more information). Therefore, the syntax of this library provides an
alternative to <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span></code>
to handle commas and leading symbols within macro parameters:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Commas and leading symbols can be used freely within elements of the
syntax that already require wrapping parenthesis (e.g., non-fundamental
parameter types <code class="computeroutput"><span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span></code>).
</li><li class="listitem">
Extra parenthesis can always be used to wrap elements of the syntax that
might contain commas and leading symbols (e.g, the base class type <code class="computeroutput"><span class="keyword">public</span> <span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span></code>).
</li><li class="listitem">
Extra parenthesis can always be used to wrap value expressions so they
can contain commas and leading symbols (e.g., a class invariants assertion
<code class="computeroutput"><span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_size</span>
<span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">()</span></code>).
</li></ol></div><p>
For example (see also <a class="ulink" href="../../example/contracts/macro_commas_symbols_integral_map.cpp" target="_top"><code class="literal">macro_commas_symbols_integral_map.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">Key</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="comment">// Commas in following template params.</span>
<span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span>
<span class="keyword">default</span> <span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;),</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">key_type</span><span class="special">)</span> <span class="identifier">default_key</span><span class="special">,</span>
<span class="keyword">default</span> <span class="special">(-</span><span class="number">1</span><span class="special">)</span>
<span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;)</span> <span class="special">)</span> <span class="comment">// Commas in concepts.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">integral_map</span><span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span> <span class="special">)</span> <span class="comment">// Commas in bases.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="comment">// Commas in class invariants.</span>
<span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_size</span><span class="special">)</span> <span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">()</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span>
<span class="identifier">iterator</span> <span class="identifier">iterator</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">OtherKey</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OtherT</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">Key</span><span class="special">&gt;),</span>
<span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">OtherT</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span>
<span class="special">)</span>
<span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&gt;)</span> <span class="special">(</span><span class="identifier">insert</span><span class="special">)</span> <span class="special">(</span> <span class="comment">// Commas in result and params.</span>
<span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">other_value</span><span class="special">,</span>
<span class="keyword">default</span> <span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">default_key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">()))</span>
<span class="special">)</span> <span class="keyword">throw</span><span class="special">(</span> <span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span> <span class="special">)</span> <span class="comment">// Commas in exception specs.</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="comment">// Leading symbols in preconditions (same for commas).</span>
<span class="special">((!</span><span class="identifier">full</span><span class="special">()))</span> <span class="comment">// LIMITATION: Two sets `((...))` (otherwise seq.).</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="comment">// Commas in postconditions.</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;::</span><span class="identifier">size_type</span><span class="special">)</span>
<span class="identifier">old_other_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span>
<span class="special">(</span><span class="identifier">size</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;()),</span>
<span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_size</span><span class="special">)</span> <span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_other_size</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">result</span><span class="special">.</span><span class="identifier">second</span> <span class="special">?</span> <span class="number">1</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="comment">// ...</span>
</pre><p>
</p><p>
(Concepts and other advanced constructs used in this example are explained
in the rest of this section and in later sections of this documentation.)
</p><p>
All these extra wrapping parenthesis are optional when there is no unwrapped
comma and no leading symbol. Programmers could chose to always program the
extra parenthesis for consistency but it is the authors' opinion that the
syntax is harder to read with the extra parenthesis so it is recommended
to use them only when strictly necessary.
</p><p>
It is also recommended to avoid using commas and leading symbols whenever
possible so to limit the cases when it is necessary to use the extra wrapping
parenthesis. For example, in many cases the leading symbol <code class="computeroutput"><span class="special">::</span></code> might not be necessary and leading symbols
like <code class="computeroutput"><span class="special">!</span></code> can be replaced by the
alternative <code class="computeroutput"><span class="keyword">not</span></code> keyword. Furthermore,
in some cases <code class="computeroutput"><span class="keyword">typedef</span></code> can be
programmed just before class and function declarations to avoid passing types
within multiple template parameters separated by commas. Declarations of
class templates and function templates are the most common cases were commas
cannot be avoided and extra wrapping parenthesis are necessarily used.
</p><div class="warning" title="Warning"><table border="0" summary="Warning"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../doc/src/images/warning.png"></td><th align="left">Warning</th></tr><tr><td align="left" valign="top"><p>
Preconditions, postconditions, and class invariants composed of one single
assertion that needs to be wrapped within extra parenthesis need to use
double parenthesis (this should be a relatively rare case). <sup>[<a name="contract__.advanced_topics.commas_and_leading_symbols_in_macros.f1" href="#ftn.contract__.advanced_topics.commas_and_leading_symbols_in_macros.f1" class="footnote">35</a>]</sup> This is the case in the above example for <code class="computeroutput"><span class="identifier">precondition</span><span class="special">(</span> <span class="special">((!</span><span class="identifier">full</span><span class="special">()))</span> <span class="special">)</span></code> (but
note that these extra parenthesis could have been avoided all together
simply using <code class="computeroutput"><span class="keyword">not</span></code> instead of
<code class="computeroutput"><span class="special">!</span></code> as in the more readable
<code class="computeroutput"><span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">full</span><span class="special">()</span> <span class="special">)</span></code>).
</p></td></tr></table></div></div><div class="section" title="Static Assertions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.static_assertions"></a><a class="link" href="#contract__.advanced_topics.static_assertions" title="Static Assertions">Static
Assertions</a></h3></div></div></div><p>
This library allows to use <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11#Static_assertions" target="_top"><span class="emphasis"><em>static
assertions</em></span></a> to program preconditions, postconditions, class
invariants, and block invariants so that they are checked at compile-time
instead of at run-time. The <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
syntax is used (but <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/mpl" target="_top">Boost.MPL</a>
<code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT_MSG</span></code> is used
to implement static assertions so no <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
feature is required):
</p><pre class="programlisting"><span class="identifier">static_assert</span><span class="special">(</span><span class="emphasis"><em>constant-boolean-condition</em></span><span class="special">,</span> <span class="emphasis"><em>constant-string-literal</em></span><span class="special">)</span>
</pre><p>
For example (see also <a class="ulink" href="../../example/contracts/static_assertion_memcopy.cpp" target="_top"><code class="literal">static_assertion_memcopy.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">From</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">To</span><span class="special">*)</span> <span class="special">(</span><span class="identifier">memcopy</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">To</span><span class="special">*)</span> <span class="identifier">to</span><span class="special">,</span> <span class="special">(</span><span class="identifier">From</span><span class="special">*)</span> <span class="identifier">from</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="comment">// Static assertions.</span>
<span class="identifier">static_assert</span><span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">To</span><span class="special">)</span> <span class="special">&gt;=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">From</span><span class="special">),</span> <span class="string">"destination too small"</span><span class="special">),</span>
<span class="comment">// Wrapping parenthesis for asserted condition with commas.</span>
<span class="identifier">static_assert</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">,</span> <span class="identifier">To</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">),</span>
<span class="string">"incompatible types"</span><span class="special">),</span>
<span class="identifier">to</span><span class="special">,</span> <span class="comment">// pointer not null</span>
<span class="identifier">from</span> <span class="comment">// pointer not null</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
</pre><p>
</p><p>
Static assertions are always checked at compile-time (regardless of them
appearing in preconditions, postconditions, etc). However, static assertions
can be selectively disabled depending on where they are specified using
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>,
etc so it is still important to logically associate them with preconditions,
postconditions, etc.
</p><p>
The string message passed as the second parameter of <code class="computeroutput"><span class="identifier">static_assert</span></code>
is ignored by the current implementation of this library (but it could be
used by future revisions of this library that take advantage of <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
features). It is recommended to always specify meaningful messages for static
assertions to increase the readability and documentation of contracts. Similarly,
it might be useful to put a short code comment following each assertions
(<code class="computeroutput"><span class="comment">// pointer not null</span></code>, etc) to
increase contract readability and documentation. <sup>[<a name="contract__.advanced_topics.static_assertions.f0" href="#ftn.contract__.advanced_topics.static_assertions.f0" class="footnote">36</a>]</sup>
</p><p>
In case of a static assertion failure, this library will generated a compile-time
error containing text similar to the following:
</p><pre class="programlisting">static_assertion_memcopy.cpp:18 ... ERROR_statically_checked_precondition_number_1_failed_at_line_18 ...
</pre><p>
This message is similar to the run-time assertion errors generated by this
library, note how it contains all the information to uniquely identify the
assertion that failed.
</p></div><div class="section" title="Constant Assertions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.constant_assertions"></a><a class="link" href="#contract__.advanced_topics.constant_assertions" title="Constant Assertions">Constant
Assertions</a></h3></div></div></div><p>
As explained in the <a class="link" href="#contract__.contract_programming_overview.constant_correctness" title="Constant-Correctness">Constant-Correctness</a>
section, contract assertions shall not change the state of the program because
contracts are only supposed to check (and not alter) the state of the program.
This library automatically makes member functions, function parameters, function
result, and old values constant so the compiler will correctly generate an
error if assertions mistakenly try to change the object, the function parameters,
the function result, or the old values (this should be sufficient in most
cases when programming contracts).
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
This library cannot automatically make constant other variables that might
be accessible by the contract assertions (e.g., global and static variables).
<sup>[<a name="contract__.advanced_topics.constant_assertions.f0" href="#ftn.contract__.advanced_topics.constant_assertions.f0" class="footnote">37</a>]</sup>
</p></td></tr></table></div><p>
This library provides <span class="emphasis"><em>constant assertions</em></span> that can be
used by programmers to explicitly make constant the variables used by the
asserted condition:
</p><pre class="programlisting"><span class="keyword">const</span><span class="special">(</span> <span class="emphasis"><em>variable1</em></span><span class="special">,</span> <span class="emphasis"><em>variable2</em></span><span class="special">,</span> <span class="special">...)</span> <span class="emphasis"><em>boolean-expression-using-variable1-variable2-...</em></span>
</pre><p>
The following example calculates the next even and odd numbers that are stored
(for some reason) in a global variable and static data member respectively
(see also <a class="ulink" href="../../example/contracts/const_assertion_number.cpp" target="_top"><code class="literal">const_assertion_number.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">unsigned</span> <span class="identifier">even</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">number</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="identifier">odd</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">next</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_even</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">even</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_odd</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">odd</span><span class="special">,</span>
<span class="comment">// `[old_]even` and `[old_]odd` all `const&amp;` within assertions.</span>
<span class="keyword">const</span><span class="special">(</span> <span class="identifier">even</span><span class="special">,</span> <span class="identifier">old_even</span> <span class="special">)</span> <span class="identifier">even</span> <span class="special">==</span> <span class="identifier">old_even</span> <span class="special">+</span> <span class="number">2</span><span class="special">,</span>
<span class="keyword">const</span><span class="special">(</span> <span class="identifier">odd</span><span class="special">,</span> <span class="identifier">old_odd</span> <span class="special">)</span> <span class="identifier">odd</span> <span class="special">==</span> <span class="identifier">old_odd</span> <span class="special">+</span> <span class="number">2</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">even</span> <span class="special">+=</span> <span class="number">2</span><span class="special">;</span>
<span class="identifier">odd</span> <span class="special">+=</span> <span class="number">2</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">unsigned</span> <span class="identifier">number</span><span class="special">::</span><span class="identifier">odd</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
</pre><p>
</p><p>
Note know the postconditions use constant assertions to force the <code class="computeroutput"><span class="identifier">even</span></code> and <code class="computeroutput"><span class="identifier">odd</span></code>
variables to be constant within each boolean expression that evaluates the
assertion. If for example the assignment operator <code class="computeroutput"><span class="special">=</span></code>
were mistakenly used instead of the equality operator <code class="computeroutput"><span class="special">==</span></code>
in the above postconditions, the compiler would correctly generate an error.
</p></div><div class="section" title="Select Assertions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.select_assertions"></a><a class="link" href="#contract__.advanced_topics.select_assertions" title="Select Assertions">Select
Assertions</a></h3></div></div></div><p>
In the <a class="link" href="#contract__.tutorial" title="Tutorial">Tutorial</a> section we have
used the ternary operator <code class="computeroutput"><span class="special">:?</span></code>
to program assertions that are guarded by a boolean condition:
</p><pre class="programlisting"><span class="identifier">old_found</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">old_found</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span>
</pre><p>
However, in cases like this one when the same boolean condition guards multiple
assertions, it might be more efficient to evaluate the guard condition only
once using one <span class="emphasis"><em>select assertion</em></span> instead of multiple
ternary operators <code class="computeroutput"><span class="special">:?</span></code>. In addition,
some programmers might find the select assertion syntax more readable than
the ternary operator <code class="computeroutput"><span class="special">:?</span></code>. For
example, the above guarded assertions could have been programmed using select
assertions as:
</p><pre class="programlisting"><span class="keyword">if</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">old_found</span><span class="special">)</span> <span class="special">(</span> <span class="comment">// Guard condition evaluated only once.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">id</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span>
<span class="special">)</span>
</pre><p>
Select assertion allow to specify an optional else-block:
</p><pre class="programlisting"><span class="keyword">if</span><span class="special">(</span><span class="emphasis"><em>boolean-condition</em></span><span class="special">)</span> <span class="special">(</span> <span class="comment">// Round parenthesis `()`.</span>
<span class="special">...</span> <span class="comment">// Comma-separated assertions.</span>
<span class="special">)</span> <span class="keyword">else</span> <span class="special">(</span> <span class="comment">// Else optional as usual.</span>
<span class="special">...</span> <span class="comment">// Comma-separated assertions.</span>
<span class="special">)</span>
</pre><p>
Note that round parenthesis <code class="computeroutput"><span class="special">(</span> <span class="special">...</span> <span class="special">)</span></code> are
used to program the then-block and else-block instead of the usual C++ curly
parenthesis <code class="computeroutput"><span class="special">{</span> <span class="special">...</span>
<span class="special">}</span></code>: Select assertions can be nested
into one another (the <code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS" title="Macro CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS">CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS</a></code>
macro specifies the maximum nesting level for select assertions).
</p><p>
For example, consider the postconditions of the following function which
calculates the factorial of a natural number (see also <a class="ulink" href="../../example/contracts/select_assertion_factorial.cpp" target="_top"><code class="literal">select_assertion_factorial.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="special">(</span><span class="identifier">factorial</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">1</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="identifier">n</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span> <span class="special">(</span> <span class="comment">// Select assertion, if-then statement.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="number">1</span>
<span class="special">)</span> <span class="keyword">else</span> <span class="special">(</span> <span class="comment">// Select assertion, else statement (optional).</span>
<span class="comment">// Assertions disabled within assertion so recursion OK.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">n</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="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="identifier">n</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span> <span class="keyword">return</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">else</span> <span class="keyword">return</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
</p><p>
Using the same syntax used for constant assertions, it is possible to force
all variables (global, static, etc) used to evaluate the if-condition of
the select assertion to be constant (see also <a class="ulink" href="../../example/contracts/const_select_assertion_factorial.cpp" target="_top"><code class="literal">const_select_assertion_factorial.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">n</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="special">(</span><span class="identifier">factorial</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">)</span> <span class="identifier">n</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">const</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">)</span> <span class="identifier">n</span> <span class="special">==</span> <span class="special">-</span><span class="number">1</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="special">(</span> <span class="comment">// Constant-correct if-condition.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="number">1</span>
<span class="special">)</span> <span class="keyword">else</span> <span class="special">(</span>
<span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">1</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">m</span> <span class="special">=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">m</span> <span class="special">==</span> <span class="number">0</span> <span class="special">||</span> <span class="identifier">m</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="number">1</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
<span class="special">--</span><span class="identifier">n</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">m</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="Assertion Statements"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.assertion_statements"></a><a class="link" href="#contract__.advanced_topics.assertion_statements" title="Assertion Statements">Assertion
Statements</a></h3></div></div></div><p>
Only assertions can be programmed within the contracts while normal C++ statements
are not allowed. This is keeps contracts simple making programming errors
within the contracts less likely and therefore increasing the probably that
error-free contracts can properly check the correctness of the implementation.
</p><p>
However, <code class="computeroutput"><span class="keyword">using</span></code> directives,
<code class="computeroutput"><span class="keyword">namespace</span></code> aliases, and <code class="computeroutput"><span class="keyword">typedef</span></code> statements are allowed within the
contracts because they only affect compilation (not altering the state of
the program at run-time) and they can be used to write more readable contracts
(for example, shortening namespaces within contract assertions). When used,
these statements have affect only locally within the preconditions, postconditions,
class invariants, etc where they appear. <sup>[<a name="contract__.advanced_topics.assertion_statements.f0" href="#ftn.contract__.advanced_topics.assertion_statements.f0" class="footnote">38</a>]</sup>
</p><p>
For example (see also <a class="ulink" href="../../example/contracts/assertion_statement_ialloc.cpp" target="_top"><code class="literal">assertion_statement_ialloc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="special">(</span><span class="identifier">T</span><span class="special">*)</span> <span class="special">(</span><span class="identifier">ialloc</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">namespace</span> <span class="identifier">mpl</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">,</span> <span class="comment">// Assertion's namespace aliasing.</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">std</span><span class="special">,</span> <span class="comment">// Assertion's using directive.</span>
<span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">pointer</span> <span class="identifier">ptr</span><span class="special">,</span> <span class="comment">// And type definition.</span>
<span class="identifier">static_assert</span><span class="special">(</span>
<span class="special">(</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">or_</span><span class="special">&lt;</span>
<span class="identifier">mpl</span><span class="special">::</span><span class="identifier">bool_</span><span class="special">&lt;</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;</span>
<span class="special">,</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">bool_</span><span class="special">&lt;</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">ptr</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">int</span><span class="special">*)&gt;</span>
<span class="special">&gt;::</span><span class="identifier">value</span><span class="special">)</span>
<span class="special">,</span> <span class="string">"within max size"</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;(</span><span class="identifier">malloc</span><span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)));</span>
<span class="special">}</span>
</pre><p>
</p><p>
These statements follow their usual C++ syntax but they are terminated with
a comma <code class="computeroutput"><span class="special">,</span></code> instead of a semicolon
<code class="computeroutput"><span class="special">;</span></code>. (The <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span></code>
macro can be used to wrap eventual commas within the <code class="computeroutput"><span class="keyword">typedef</span></code>
statement.)
</p></div><div class="section" title="Assertion Requirements"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.assertion_requirements"></a><a class="link" href="#contract__.advanced_topics.assertion_requirements" title="Assertion Requirements">Assertion
Requirements</a></h3></div></div></div><p>
In general, programming contract assertions can introduce a new set of requirements
on the types used by the program. Some of these type requirements might be
necessary only to program the assertions and they might not be required by
the implementation itself. In such cases, if the code is compiled with contracts
disabled (<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
etc), the program might compile but it might no longer compile when contracts
are enabled because some of the types do not provide all the operations necessary
to check the contract assertions.
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
More in general, in some cases it might be acceptable or even desirable
to cause a compile-time error when a program uses types that do not provide
all the operations needed to check the contracts (because it is not possible
to fully check the correctness of the program). In these cases, programmers
specify contract assertions as we have seen so far (and maybe even use
concepts to explicitly specify the contract type requirements, see the
<a class="link" href="#contract__.concepts" title="Concepts">Concepts</a> section).
</li><li class="listitem">
However, in other cases it might be desirable that adding contracts to
a program does not change its type requirements and that assertions are
simply not checked when the types do not provide all the operations necessary
to evaluate the asserted conditions. In these cases, programmers can
use <span class="emphasis"><em>assertion requirements</em></span> to disable compilation
and run-time checking of specific assertions: <sup>[<a name="contract__.advanced_topics.assertion_requirements.f0" href="#ftn.contract__.advanced_topics.assertion_requirements.f0" class="footnote">39</a>]</sup>
</li></ol></div><pre class="programlisting"><span class="emphasis"><em>assertion</em></span><span class="special">,</span> <span class="identifier">requires</span> <span class="emphasis"><em>constant-boolean-expression</em></span>
</pre><p>
(The constant boolean expression of an assertion requirement can be wrapped
within round parenthesis <code class="computeroutput"><span class="special">()</span></code>
if it contains unwrapped commas.)
</p><p>
Let's consider the STL <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
class template. This template normally does not require the value type <code class="computeroutput"><span class="identifier">T</span></code> to be <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>
(i.e., to have an equality operator <code class="computeroutput"><span class="special">==</span></code>),
it only requires <code class="computeroutput"><span class="identifier">T</span></code> to be
<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/CopyConstructible.html" target="_top"><code class="literal">CopyConstructible</code></a>
(i.e., to have a copy constructor). However, in order to check the following
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">push_back</span></code> postcondition:
</p><pre class="programlisting"><span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span> <span class="comment">// Compiler error if not `EqualityComparable&lt;T&gt;`.</span>
</pre><p>
The type <code class="computeroutput"><span class="identifier">T</span></code> must to be <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>.
Therefore, the <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>
requirement on <code class="computeroutput"><span class="identifier">T</span></code> is introduced
only by the contract assertions and it is not required by the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
implementation.
</p><p>
In some cases, programmers might want compilation to fail when <code class="computeroutput"><span class="identifier">T</span></code> is not <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>
because in these cases it is not possible to fully check the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
contract and therefore its correctness (in these cases programmers do not
specify assertion requirements and let the compilation fail, or even better
programmers can explicitly specify the assertion type requirements using
concepts which will also fail compilation but hopefully with more informative
error messages, see the <a class="link" href="#contract__.concepts" title="Concepts">Concepts</a>
section).
</p><p>
However, in other cases programmers might want to use the contracted version
of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> exactly
as they use the non-contracted version of the template and therefore without
failing compilation if <code class="computeroutput"><span class="identifier">T</span></code>
is not <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>.
This can be achieved specifying assertion requirements for the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">push_back</span></code> postcondition:
</p><pre class="programlisting"><span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="comment">// No error if not `EqualityComparable&lt;T&gt;`.</span>
</pre><p>
This postcondition will be checked only when <code class="computeroutput"><span class="identifier">T</span></code>
is <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>,
otherwise the postcondition will be ignored otherwise causing no compilation
error.
</p><p>
For example (see also <a class="ulink" href="../../example/contracts/assertion_requirements_push_back.cpp" target="_top"><code class="literal">assertion_requirements_push_back.cpp</code></a>):
<sup>[<a name="contract__.advanced_topics.assertion_requirements.f1" href="#ftn.contract__.advanced_topics.assertion_requirements.f1" class="footnote">40</a>]</sup>
</p><p>
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">vector</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">()</span>
<span class="comment">// ...</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span><span class="special">,</span>
<span class="comment">// Requirements disable assertion if `T` has no `operator==`.</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="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</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><p>
</p><pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">num</span> <span class="comment">// Not equality comparable.</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">value</span><span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">num</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">a_value</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">value</span><span class="special">(</span><span class="identifier">a_value</span><span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">i</span><span class="special">;</span>
<span class="identifier">i</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;</span> <span class="identifier">n</span><span class="special">;</span>
<span class="identifier">n</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">num</span><span class="special">(</span><span class="number">123</span><span class="special">));</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">);</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
The <code class="computeroutput"><span class="identifier">i</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="number">123</span><span class="special">)</span></code> call will
check the postcondition <code class="computeroutput"><span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span></code>
because <code class="computeroutput"><span class="keyword">int</span></code> is <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>
and the assertion requirement <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true. However, the <code class="computeroutput"><span class="identifier">n</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">num</span><span class="special">(</span><span class="number">123</span><span class="special">))</span></code> call
will not check, and in fact not even compile, the postconditions <code class="computeroutput"><span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span></code>
because <code class="computeroutput"><span class="identifier">num</span></code> is not <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>
and the assertion requirement <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
is false. <sup>[<a name="contract__.advanced_topics.assertion_requirements.f2" href="#ftn.contract__.advanced_topics.assertion_requirements.f2" class="footnote">41</a>]</sup>
</p><p>
The <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/type_traits" target="_top">Boost.TypeTraits</a>
library provides a set of meta-functions that are very useful to program
assertion requirements. <sup>[<a name="contract__.advanced_topics.assertion_requirements.f3" href="#ftn.contract__.advanced_topics.assertion_requirements.f3" class="footnote">42</a>]</sup> However, C++ does not allow to inspect every trait of a type
so there might be some assertion requirements that unfortunately cannot be
programmed within the language.
</p><p>
Another interesting use of assertion requirements is to model assertion computational
complexity. In some cases, checking assertions can be as computationally
expensive as executing the function body or even more. While preconditions,
postconditions, etc can be disabled in groups at compile-time to improve
performance (using <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>,
etc), it is also useful to be able to disable only specific assertions that
are very computationally expensive while keeping all other preconditions,
postconditions, etc enabled. For example (see also <a class="ulink" href="../../example/contracts/assertion_complexity_factorial.cpp" target="_top"><code class="literal">assertion_complexity_factorial.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="comment">// Assertion requirements used to model assertion computational complexity.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_1</span> <span class="number">0</span> <span class="comment">// O(1) constant (default).</span>
<span class="preprocessor">#define</span> <span class="identifier">O_N</span> <span class="number">1</span> <span class="comment">// O(n) linear.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_NN</span> <span class="number">2</span> <span class="comment">// O(n * n) quadratic.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_NX</span> <span class="number">3</span> <span class="comment">// O(n^x) polynomial.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_FACTN</span> <span class="number">4</span> <span class="comment">// O(n!) factorial.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_EXPN</span> <span class="number">5</span> <span class="comment">// O(e^n) exponential.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_ALL</span> <span class="number">10</span>
<span class="preprocessor">#define</span> <span class="identifier">COMPLEXITY_MAX</span> <span class="identifier">O_ALL</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="special">(</span><span class="identifier">factorial</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">n</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">1</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">n</span> <span class="special">&lt;</span> <span class="number">2</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="number">1</span>
<span class="special">)</span> <span class="keyword">else</span> <span class="special">(</span>
<span class="comment">// Assertion compiled and checked only if within complexity.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">O_FACTN</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span>
<span class="special">)</span>
<span class="special">)</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">&lt;</span> <span class="number">2</span><span class="special">)</span> <span class="keyword">return</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">else</span> <span class="keyword">return</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
</p><p>
In this case the postcondition <code class="computeroutput"><span class="identifier">result</span>
<span class="special">=</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span>
<span class="number">1</span><span class="special">)</span></code>
has factorial computation complexity and it is compiled and checked at run-time
only if the macro <code class="computeroutput"><span class="identifier">COMPLEXITY_MAX</span></code>
is defined to be <code class="computeroutput"><span class="identifier">O_FACTN</span></code>
or greater. Similarly, macros like <code class="computeroutput"><span class="identifier">O_SMALLER_BODY</span></code>,
<code class="computeroutput"><span class="identifier">O_BODY</span></code>, and <code class="computeroutput"><span class="identifier">O_GREATER_BODY</span></code> could have been defined
to express computational complexity in relative terms with respect to the
body computational complexity (see the <a class="link" href="#contract__.examples" title="Examples">Examples</a>
section). <sup>[<a name="contract__.advanced_topics.assertion_requirements.f4" href="#ftn.contract__.advanced_topics.assertion_requirements.f4" class="footnote">43</a>]</sup>
</p><p>
Assertion requirements can be used with assertions, constant assertions,
and static assertions but they cannot be used with assertion statements and
with the if-then-else statements of select assertions (however, if select
assertions are programmed using the ternary operator <code class="computeroutput"><span class="special">:?</span></code>
then assertion requirements will disable the entire ternary operator <code class="computeroutput"><span class="special">:?</span></code> expression including its if-condition).
</p></div><div class="section" title="Old-Of Requirements"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.old_of_requirements"></a><a class="link" href="#contract__.advanced_topics.old_of_requirements" title="Old-Of Requirements">Old-Of
Requirements</a></h3></div></div></div><p>
Assertion requirements can be specified also for postconditions that use
old values. However, old values have the additional requirement that the
type of the expression passed to the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code>
macro must be <a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies"><code class="literal">ConstantCopyConstructible</code></a>.
If such a requirement is not met:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Either, programmers want the compiler to error because the postconditions
using the old value cannot be evaluated (in which case programmers will
not specify assertion requirements and they might explicitly specify
type requirements using concepts so to get more informative error messages,
see the <a class="link" href="#contract__.concepts" title="Concepts">Concepts</a> section).
</li><li class="listitem">
Or, programmers want the old value declaration that uses the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code> macro to have no effect
(because the old value cannot be copied) and the postconditions using
such an old value to not be evaluated.
</li></ol></div><p>
Unfortunately, C++ cannot automatically detect if a type has a copy constructor
therefore a special trait <code class="computeroutput"><a class="link" href="#contract.has_oldof" title="Struct template has_oldof">contract::has_oldof</a></code>
had to be introduced to support this second case. The <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">has_oldof</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
trait is a unary boolean meta-function which is <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span></code> by default for any type <code class="computeroutput"><span class="identifier">T</span></code> and it must be specialized by programmers
for types which old values cannot be copied.
</p><p>
For example, consider the following increment function (see also <a class="ulink" href="../../example/contracts/has_oldof_inc.cpp" target="_top"><code class="literal">has_oldof_inc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">inc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">offset</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span><span class="special">,</span> <span class="comment">// Skip if no old-of.</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="comment">// Never skipped.</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="identifier">offset</span><span class="special">,</span> <span class="identifier">requires</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">has_oldof</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="keyword">and</span> <span class="comment">// Requires old-of.</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="keyword">and</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">requires</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span> <span class="special">+=</span> <span class="identifier">offset</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">class</span> <span class="identifier">num</span> <span class="special">:</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span> <span class="comment">// Non-copyable (for some reason...).</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">num</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">value</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">ptr_</span><span class="special">(</span><span class="keyword">new</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">value</span><span class="special">))</span> <span class="special">{}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">num</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">other</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">ptr_</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">)</span> <span class="special">{}</span> <span class="comment">// Private copy.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="special">~</span><span class="identifier">num</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">delete</span> <span class="identifier">ptr_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">num</span> <span class="keyword">operator</span><span class="special">+</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">num</span><span class="special">(*</span><span class="identifier">ptr_</span> <span class="special">+</span> <span class="special">*</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">);</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">num</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">+=</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span> <span class="special">*</span><span class="identifier">ptr_</span> <span class="special">+=</span> <span class="special">*</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="identifier">ptr_</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span><span class="special">*</span> <span class="identifier">ptr_</span><span class="special">;</span>
<span class="special">};</span>
<span class="comment">// Specialization disables old-of for non-copyable `num` (no C++ type trait can</span>
<span class="comment">// automatically detect copy constructors).</span>
<span class="keyword">namespace</span> <span class="identifier">contract</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">has_oldof</span> <span class="special">&lt;</span> <span class="identifier">num</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span> <span class="special">{};</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">inc</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">j</span><span class="special">)</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">num</span> <span class="identifier">n</span><span class="special">(</span><span class="number">1</span><span class="special">),</span> <span class="identifier">m</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">inc</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span> <span class="identifier">m</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">num</span><span class="special">(</span><span class="number">3</span><span class="special">));</span>
</pre><p>
</p><p>
In this example, the <code class="computeroutput"><span class="identifier">num</span></code>
type is non-copyable so the <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">has_oldof</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;</span></code> specialization inherits from <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span></code>.
As a consequence, the call <code class="computeroutput"><span class="identifier">inc</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span>
<span class="identifier">m</span><span class="special">)</span></code>
will automatically skip the old value declaration:
</p><pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span>
</pre><p>
The following postcondition will also be skipped because its assertion requirement
lists <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">has_oldof</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> (where
<code class="computeroutput"><span class="identifier">T</span></code> is indeed the type of
<code class="computeroutput"><span class="identifier">value</span></code> passed to the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code> macro):
</p><pre class="programlisting"><span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="identifier">offset</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">contract</span><span class="special">::</span><span class="identifier">has_oldof</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span> <span class="special">...</span>
</pre><p>
Note how this postcondition actually requires the type <code class="computeroutput"><span class="identifier">T</span></code>
to have an old value, a plus operator <code class="computeroutput"><span class="special">+</span></code>,
and an equality operator <code class="computeroutput"><span class="special">==</span></code>
thus all of these requirements are programmed in the assertion requirements.
</p><p>
Finally, return value declarations are never skipped so there is no <code class="computeroutput"><span class="identifier">has_result</span></code> trait. <sup>[<a name="contract__.advanced_topics.old_of_requirements.f0" href="#ftn.contract__.advanced_topics.old_of_requirements.f0" class="footnote">44</a>]</sup>
</p></div><div class="section" title="Old and Result Value Copies"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.old_and_result_value_copies"></a><a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies">Old
and Result Value Copies</a></h3></div></div></div><p>
This library uses the class template <code class="computeroutput"><a class="link" href="#contract.copy" title="Class template copy">contract::copy</a></code>
to copy old values and the result value for postconditions.
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">contract</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">copy</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">copy</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">object</span> <span class="special">)</span> <span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
The default implementation of the <code class="computeroutput"><a class="link" href="#contract.copy" title="Class template copy">contract::copy</a></code>
class template requires that the type of the old value expression passed
to the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code> macro and
the result type are <a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies"><code class="literal">ConstantCopyConstructible</code></a>
(i.e., these types provide a copy constructor that copies the object from
a constant reference, the reference has to be constant so to ensure the constant-correctness
of the copy operations that are executed within the contracts, see also the
<a class="link" href="#contract__.contract_programming_overview.constant_correctness" title="Constant-Correctness">Constant-Correctness</a>
section):
</p><pre class="programlisting"><span class="comment">// `ConstantCopyConstructible&lt;T&gt;` (which implies `CopyConstructible&lt;T&gt;`):</span>
<span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">source</span> <span class="special">)</span> <span class="special">;</span> <span class="comment">// OK: constant-correct copy constructor.</span>
<span class="comment">// `CopyConstructible&lt;T&gt;` (but not `ConstantCopyConstructible&lt;T&gt;`):</span>
<span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">source</span> <span class="special">)</span> <span class="special">;</span> <span class="comment">// Error, copy constructor is not constant-correct.</span>
</pre><p>
Programmers can specialize the <code class="computeroutput"><a class="link" href="#contract.copy" title="Class template copy">contract::copy</a></code>
class template to allow old value and result value copies even for types
that are not <a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies"><code class="literal">ConstantCopyConstructible</code></a>
(in this case it is the programmers' responsibility to make sure that the
copy operations that they define are constant-correct, otherwise the contracts
will no longer be constant-correct). <sup>[<a name="contract__.advanced_topics.old_and_result_value_copies.f0" href="#ftn.contract__.advanced_topics.old_and_result_value_copies.f0" class="footnote">45</a>]</sup>
</p><p>
In the following example the old and result value declarations use the specialization
<code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">copy</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;</span></code>
so it is possible to access the old and result value of variables of type
<code class="computeroutput"><span class="identifier">num</span></code> even if <code class="computeroutput"><span class="identifier">num</span></code> is non-copyable (see also <a class="ulink" href="../../example/contracts/copy_inc.cpp" target="_top"><code class="literal">copy_inc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">inc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">offset</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span><span class="special">,</span> <span class="comment">// Use `copy`.</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="comment">// Would use `copy` but reference so no copy.</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="identifier">offset</span><span class="special">,</span> <span class="identifier">requires</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_plus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="keyword">and</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">requires</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span> <span class="special">+=</span> <span class="identifier">offset</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">class</span> <span class="identifier">num</span> <span class="special">:</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span> <span class="comment">// Non-copyable (for some reason...).</span>
<span class="special">{</span>
<span class="keyword">friend</span> <span class="keyword">class</span> <span class="identifier">contract</span><span class="special">::</span><span class="identifier">copy</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;;</span> <span class="comment">// Contract copy is friend.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">num</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">value</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">ptr_</span><span class="special">(</span><span class="keyword">new</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">value</span><span class="special">))</span> <span class="special">{}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">num</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">other</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">ptr_</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">)</span> <span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="special">~</span><span class="identifier">num</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">delete</span> <span class="identifier">ptr_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">num</span> <span class="keyword">operator</span><span class="special">+</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">num</span><span class="special">(*</span><span class="identifier">ptr_</span> <span class="special">+</span> <span class="special">*</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">);</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">num</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">+=</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span> <span class="special">*</span><span class="identifier">ptr_</span> <span class="special">+=</span> <span class="special">*</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">;</span> <span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="special">*</span><span class="identifier">ptr_</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span><span class="special">*</span> <span class="identifier">ptr_</span><span class="special">;</span>
<span class="special">};</span>
<span class="comment">// Specialization disables old-of for non-copyable `num` (no C++ type trait can</span>
<span class="comment">// automatically detect copy constructors).</span>
<span class="keyword">namespace</span> <span class="identifier">contract</span>
<span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">copy</span> <span class="special">&lt;</span> <span class="identifier">num</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">copy</span> <span class="special">(</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">n</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">num_</span><span class="special">(*</span><span class="identifier">n</span><span class="special">.</span><span class="identifier">ptr_</span><span class="special">)</span> <span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">num</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">num_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">num</span> <span class="identifier">num_</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">inc</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">j</span><span class="special">)</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">num</span> <span class="identifier">n</span><span class="special">(</span><span class="number">1</span><span class="special">),</span> <span class="identifier">m</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">inc</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span> <span class="identifier">m</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">num</span><span class="special">(</span><span class="number">3</span><span class="special">));</span>
</pre><p>
</p><p>
Both calls <code class="computeroutput"><span class="identifier">inc</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">j</span><span class="special">)</span></code> and <code class="computeroutput"><span class="identifier">inc</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span>
<span class="identifier">m</span><span class="special">)</span></code>
check all postconditions. The first call copies the old and result values
using <code class="computeroutput"><span class="keyword">int</span></code>'s default copy constructor,
the second call copies the old and result values using the copy operation
implemented by the <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">copy</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;</span></code> specialization.
</p></div><div class="section" title="Pure Virtual Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.pure_virtual_functions"></a><a class="link" href="#contract__.advanced_topics.pure_virtual_functions" title="Pure Virtual Functions">Pure
Virtual Functions</a></h3></div></div></div><p>
It is possible to program contracts for pure virtual functions. Pure virtual
functions are specified with the usual <code class="computeroutput"><span class="special">=</span>
<span class="number">0</span><span class="special">;</span></code>
symbol replacing the function definition just after the contract macros,
for example (see also <a class="ulink" href="../../example/contracts/pushable.hpp" target="_top"><code class="literal">pushable.hpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">pushable</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Subcontracting: In `and` with derived class invariants.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span> <span class="keyword">new</span>
<span class="comment">// Subcontracting: In `or` with overriding function preconditions.</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">false</span> <span class="special">)</span> <span class="comment">// Force check to overriding preconditions.</span>
<span class="comment">// Subcontracting: In `and` with overriding function postconditions.</span>
<span class="identifier">postcondition</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="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Contract for pure virtual function.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">virtual</span> <span class="identifier">const_reference</span> <span class="identifier">back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p></div><div class="section" title="Subcontracting Preconditions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.subcontracting_preconditions"></a><a class="link" href="#contract__.advanced_topics.subcontracting_preconditions" title="Subcontracting Preconditions">Subcontracting
Preconditions</a></h3></div></div></div><p>
While subcontracting is theoretically sound and justified by the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a>, in practise subcontracted preconditions might be confusing
for programmers because of the implications of evaluating overriding preconditions
in <a class="link" href="#logic_or_anchor">logic-or</a> with overridden preconditions
(this is not the case for subcontracted postconditions and class invariants
which usually behave as programmers expect because they are evaluated in
<a class="link" href="#logic_and_anchor">logic-and</a>).
</p><p>
For example, consider the following base class <code class="computeroutput"><span class="identifier">integer</span></code>
which holds an integral value and its derived class <code class="computeroutput"><span class="identifier">natural</span></code>
which holds a natural (i.e., non-negative integer) value (see also <a class="ulink" href="../../example/contracts/subcontract_pre_natural_failure.cpp" target="_top"><code class="literal">subcontract_pre_natural_failure.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">integer</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">set</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="comment">// No preconditions so this and all overrides can always be called.</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">get</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="identifier">value_</span> <span class="special">=</span> <span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">get</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">natural</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">integer</span> <span class="special">)</span> <span class="comment">// Subcontract.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="identifier">get</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">set</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">value</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// NOTE: Will not fail because of base.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">integer</span><span class="special">,</span> <span class="identifier">set</span><span class="special">)(</span><span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre><p>
</p><p>
From reading the contracts we conclude that:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
<code class="computeroutput"><span class="identifier">integer</span><span class="special">::</span><span class="identifier">get</span></code> returns the latest value set (as
specified by <code class="computeroutput"><span class="identifier">integer</span><span class="special">::</span><span class="identifier">set</span></code>
postconditions).
</li><li class="listitem">
There is no constraint on the integer value that is passed to <code class="computeroutput"><span class="identifier">integer</span><span class="special">::</span><span class="identifier">set</span></code> (because <code class="computeroutput"><span class="identifier">integer</span><span class="special">::</span><span class="identifier">set</span></code>
has no precondition).
</li><li class="listitem">
<code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">get</span></code> always returns a non-negative value
(as specified by the <code class="computeroutput"><span class="identifier">natural</span></code>
class invariants).
</li><li class="listitem">
Only non-negative values can be passed to <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code>
(as specified by <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code>
preconditions).
</li></ul></div><p>
This last conclusion is incorrect! Negative values can be passed to <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> because they can be passed to its base
virtual function <code class="computeroutput"><span class="identifier">integral</span><span class="special">::</span><span class="identifier">set</span></code> (preconditions
cannot only be weakened). The complete set of <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> preconditions
is given by its base virtual function <code class="computeroutput"><span class="identifier">integer</span><span class="special">::</span><span class="identifier">set</span></code> preconditions
(which are always <code class="computeroutput"><span class="keyword">true</span></code> because
they are not specified) evaluated in <a class="link" href="#logic_or_anchor">logic-or</a>
with the preconditions explicitly specified by <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> (i.e.,
<code class="computeroutput"><span class="identifier">value</span> <span class="special">&gt;=</span>
<span class="number">0</span></code>):
</p><pre class="programlisting"><span class="special">(</span><span class="keyword">true</span><span class="special">)</span> <span class="keyword">or</span> <span class="special">(</span><span class="identifier">value</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">)</span>
</pre><p>
Obviously, this always evaluates to <code class="computeroutput"><span class="keyword">true</span></code>
regardless of <code class="computeroutput"><span class="identifier">value</span></code> being
non-negative. This is correct in accordance with the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a> for which <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> can
be called in any context where <code class="computeroutput"><span class="identifier">integer</span><span class="special">::</span><span class="identifier">set</span></code> is
called because <code class="computeroutput"><span class="identifier">natural</span></code> inherits
from <code class="computeroutput"><span class="identifier">integer</span></code>. Given that
<code class="computeroutput"><span class="identifier">integer</span><span class="special">::</span><span class="identifier">set</span></code> can be called regardless of <code class="computeroutput"><span class="identifier">value</span></code> being non-negative (because it has
no precondition) there is no precondition that we can later specify for
<code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> that will change that and in fact
<code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> can also be called with negative values
without failing its subcontracted preconditions. For example, the call:
</p><p>
</p><pre class="programlisting"><span class="identifier">natural</span> <span class="identifier">n</span><span class="special">;</span>
<span class="identifier">n</span><span class="special">.</span><span class="identifier">set</span><span class="special">(-</span><span class="number">123</span><span class="special">);</span> <span class="comment">// Error: Fails call invariants instead of preconditions.</span>
</pre><p>
</p><p>
Fails the class invariants checked while exiting <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code>:
</p><pre class="programlisting">class invariant (on exit) number 1 "get() &gt;= 0" failed: file "natural_subcontractpre.cpp", line 30
</pre><p>
Ideally, this call would have failed much earlier at <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> preconditions
(in fact, the <code class="computeroutput"><span class="identifier">natural</span><span class="special">::</span><span class="identifier">set</span></code> body is executed with the logically
invalid negative value <code class="computeroutput"><span class="special">-</span><span class="number">123</span></code>
which could in general lead to catastrophic errors and mysterious bugs).
</p><p>
The issue here is in the design. A natural number is not an integer number
because while it is valid to use an integer number in a context where it
is assigned to a negative number, it is not valid to use a natural number
in such a context so a natural number should not inherit from an integer
number. Inheritance models the <a class="ulink" href="http://en.wikipedia.org/wiki/Is-a" target="_top"><span class="emphasis"><em>is-a</em></span></a>
relationship which should not be used in this case as the contracts and the
<a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a> are telling us.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
Note that if a virtual member function has no preconditions, it means that
it is always valid to call it, and (in accordance with the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a>) this semantic cannot be changed by the contracts of
any overriding function no matter what preconditions we specify for it.
Similarly, if an overriding member function has no preconditions, it means
that is is always valid to call it regardless of possible preconditions
specified by any function that it overrides.
</p></td></tr></table></div><p>
An overriding function can specify <code class="computeroutput"><span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">false</span> <span class="special">)</span></code>
if it wants to keep the same preconditions of the functions that is overriding.
A pure virtual function can specify <code class="computeroutput"><span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">false</span> <span class="special">)</span></code>
to indicate that overriding functions will specify preconditions (this only
makes sense for pure virtual functions because a function with <code class="computeroutput"><span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">false</span> <span class="special">)</span></code>
can never be called successfully unless it is overridden and its preconditions
are weakened, that might be acceptable for pure virtual because they must
always be overridden).
</p><p>
If programmers find subcontracted preconditions confusing, this library allows
to forbid them by defining the configuration macro <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS" title="Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS">CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</a></code>.
When this macro if defined, the library will generate a compile-time error
if a derived class tries to override preconditions of member functions of
any of its base classes (this is also the subcontracting behaviour specified
by <a class="link" href="#N1962_anchor">[N1962]</a>). However, note that in case
of multiple-inheritance preconditions from the overridden function from all
bases classes will always be checked in <a class="link" href="#logic_or_anchor">logic-or</a>
with each other so preconditions from a base class could still be weaken
by the preconditions of another base class even when the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS" title="Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS">CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</a></code>
macro is defined. By default the <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS" title="Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS">CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</a></code>
macro is not defined and this library allows to override preconditions (as
specified by for <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
by <a class="link" href="#Meyer97_anchor">[Meyer97]</a> and in accordance with
the <a class="ulink" href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" target="_top">substitution
principle</a>).
</p><p>
Another difference between subcontracted preconditions and subcontracted
postconditions or class invariants is that subcontracted preconditions will
always report a failure of the overridden preconditions. For example, consider
a set of base classes <code class="literal">b<span class="emphasis"><em>N</em></span></code> and a derived
class <code class="computeroutput"><span class="identifier">d</span></code>:
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">a</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="special">...</span> <span class="comment">// No member function `f`.</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">b</span><span class="emphasis"><em>N</em></span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Overridden function.</span>
<span class="identifier">precondition</span><span class="special">(</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="special">)</span> <span class="special">{}</span>
<span class="special">...</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">c</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="special">...</span> <span class="comment">// No member function `f`.</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">d</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="identifier">b1</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">b2</span><span class="special">,</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">b3</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Overriding function.</span>
<span class="identifier">precondition</span><span class="special">(</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="special">)</span> <span class="special">{}</span>
<span class="special">...</span>
<span class="special">};</span>
</pre><p>
When <code class="computeroutput"><span class="identifier">d</span><span class="special">::</span><span class="identifier">f</span></code> is called, its subcontracted class invariants,
postconditions, and preconditions are evaluated using the following expressions
(the base classes <code class="computeroutput"><span class="identifier">a</span></code> and
<code class="computeroutput"><span class="identifier">c</span></code> do not declare a virtual
function <code class="computeroutput"><span class="identifier">f</span></code> so they are automatically
excluded from <code class="computeroutput"><span class="identifier">d</span><span class="special">::</span><span class="identifier">f</span></code> subcontracting):
</p><pre class="programlisting"><span class="identifier">b1</span><span class="special">::</span><span class="emphasis"><em>class-invariants</em></span> <span class="keyword">and</span> <span class="identifier">b2</span><span class="special">::</span><span class="emphasis"><em>class-invariants</em></span> <span class="keyword">and</span> <span class="identifier">b3</span><span class="special">::</span><span class="emphasis"><em>class-invariants</em></span> <span class="keyword">and</span> <span class="identifier">d</span><span class="special">::</span><span class="emphasis"><em>class-invariants</em></span> <span class="comment">// `d::f` subcontracted class invariants.</span>
<span class="identifier">b1</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>postconditions</em></span> <span class="keyword">and</span> <span class="identifier">b2</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>postconditions</em></span> <span class="keyword">and</span> <span class="identifier">b3</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>postconditions</em></span> <span class="keyword">and</span> <span class="identifier">d</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>postconditions</em></span> <span class="comment">// `d::f` subcontracted postconditions.</span>
<span class="identifier">b1</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>preconditions</em></span> <span class="keyword">or</span> <span class="identifier">b2</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>preconditions</em></span> <span class="keyword">or</span> <span class="identifier">b3</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>preconditions</em></span> <span class="keyword">or</span> <span class="identifier">d</span><span class="special">::</span><span class="identifier">f</span><span class="special">::</span><span class="emphasis"><em>preconditions</em></span> <span class="comment">// `d::f` subcontracted preconditions.</span>
</pre><p>
When subcontracted class invariants or subcontracted postconditions fail,
this library reports the first failed condition which can in general be in
the base class contracts because they are checked first in the <a class="link" href="#logic_and_anchor">logic-and</a>
chain (this can report a failure from any subcontracted class invariants
<code class="literal">b<span class="emphasis"><em>N</em></span>::<span class="emphasis"><em>class-invariants</em></span></code>
or <code class="literal">d::<span class="emphasis"><em>class-invariants</em></span></code>, and subcontracted
postconditions <code class="literal">b<span class="emphasis"><em>N</em></span>::f::<span class="emphasis"><em>postconditions</em></span></code>
or <code class="literal">d::f::<span class="emphasis"><em>postconditions</em></span></code>). However,
when subcontracted preconditions fail it means that all overridden preconditions
as well as the overriding preconditions have failed (because subcontracted
preconditions are evaluated in <a class="link" href="#logic_or_anchor">logic-or</a>).
In this case, this library will report the last evaluated failure which will
always be in the overriding preconditions (always report a failure from
<code class="literal">d::f::<span class="emphasis"><em>preconditions</em></span></code>). If programmers
want instead the library to report the failure from the first overridden
precondition that failed, they can define the configuration macro <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE" title="Macro CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE">CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE</a></code>
(always report a failure from <code class="literal">b1::f::<span class="emphasis"><em>preconditions</em></span></code>).
</p></div><div class="section" title="Static Member Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.static_member_functions"></a><a class="link" href="#contract__.advanced_topics.static_member_functions" title="Static Member Functions">Static
Member Functions</a></h3></div></div></div><p>
It is possible to program contracts for static member functions. Static member
functions cannot access the object therefore their preconditions and postconditions
also cannot access the object and they can only access other static members.
This library allows to specify a subset of class invariants called <span class="emphasis"><em>static
class invariants</em></span> which do not access the object and that are checked
at entry and exit of every constructor, destructor, and member functions
even if static. (Non-static class invariants are instead not checked at constructor
entry, at destructor exit, and at entry and exit of static member functions
because they require accessing the object, see also the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract
Programming Overview</a> section.)
</p><p>
Static class invariants are empty (<code class="computeroutput"><span class="keyword">void</span></code>)
by default unless they are explicitly specified within the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code>
macro using the following syntax: <sup>[<a name="contract__.advanced_topics.static_member_functions.f0" href="#ftn.contract__.advanced_topics.static_member_functions.f0" class="footnote">46</a>]</sup>
</p><pre class="programlisting"><span class="keyword">static</span> <span class="keyword">class</span><span class="special">(</span> <span class="emphasis"><em>assertion1</em></span><span class="special">,</span> <span class="emphasis"><em>assertion2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
</pre><p>
For example (see also <a class="ulink" href="../../example/contracts/static_contract_instance_counter.cpp" target="_top"><code class="literal">static_contract_instance_counter.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">instance_counter</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">object</span><span class="special">(),</span> <span class="comment">// Non-static class invariants.</span>
<span class="keyword">static</span> <span class="keyword">class</span><span class="special">(</span> <span class="comment">// Static class invariants.</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span>
<span class="comment">// ...</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">instance_counter</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span><span class="special">*)</span> <span class="identifier">the_object</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">the_object</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">object</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">the_object</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">object_</span><span class="special">(</span><span class="identifier">the_object</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">count_</span><span class="special">++;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">instance_counter</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="comment">// FUTURE: Destructors could have static postconditions.</span>
<span class="comment">// postcondition: count() = oldof count() - 1</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">delete</span> <span class="identifier">object_</span><span class="special">;</span>
<span class="identifier">count_</span><span class="special">--;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">*</span> <span class="keyword">const</span><span class="special">)</span> <span class="special">(</span><span class="identifier">object</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">object_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Contract static member function.</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="comment">// No preconditions nor postconditions for this example but when</span>
<span class="comment">// present no object can be accessed by assertions (i.e., `static`).</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">count_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">int</span> <span class="identifier">count_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">object_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">instance_counter</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">count_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
</pre><p>
</p><p>
In this example there is only one static class invariant assertion <code class="computeroutput"><span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span></code> and
it is checked at entry and exit of every constructor, destructor, and member
function including the static member function <code class="computeroutput"><span class="identifier">count</span></code>.
If the static member function <code class="computeroutput"><span class="identifier">count</span></code>
had preconditions or postconditions, they would not be able to access the
object (i.e., preconditions and postconditions will also be executed in static
context).
</p></div><div class="section" title="Volatile Member Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.volatile_member_functions"></a><a class="link" href="#contract__.advanced_topics.volatile_member_functions" title="Volatile Member Functions">Volatile
Member Functions</a></h3></div></div></div><p>
It is possible to program contracts for volatile member functions. Volatile
member functions access the object as volatile therefore their preconditions
and postconditions also access the object as volatile and can only access
other volatile members. This library allows to specify a different set of
class invariants called <span class="emphasis"><em>volatile class invariants</em></span> which
can only access the object as volatile and that are checked at entry and
exit of every volatile member function. (Constructors and destructors never
access the object as volatile so volatile class invariants are not checked
by constructors and destructors, see also the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract
Programming Overview</a> section.)
</p><p>
Volatile class invariants are assumed to be the same as non-volatile class
invariants unless they are explicitly specified within the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code>
macro using the following syntax: <sup>[<a name="contract__.advanced_topics.volatile_member_functions.f0" href="#ftn.contract__.advanced_topics.volatile_member_functions.f0" class="footnote">47</a>]</sup>
</p><pre class="programlisting"><span class="keyword">volatile</span> <span class="keyword">class</span><span class="special">(</span> <span class="emphasis"><em>assertion1</em></span><span class="special">,</span> <span class="emphasis"><em>assertion2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
</pre><p>
In most cases, it will be necessary to explicitly specify volatile class
invariants when using volatile member functions (unless volatile overloads
are provided for every member function that is used by the non-volatile class
invariants).
</p><p>
For example (see also <a class="ulink" href="../../example/contracts/volatile_contract_shared_instance.cpp" target="_top"><code class="literal">volatile_contract_shared_instance.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">shared_instance</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">queries</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">,</span> <span class="comment">// Non-volatile class invariants.</span>
<span class="keyword">volatile</span> <span class="keyword">class</span><span class="special">(</span> <span class="comment">// Volatile class invariants.</span>
<span class="identifier">object</span><span class="special">()</span>
<span class="comment">// ...</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">shared_instance</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span><span class="special">*)</span> <span class="identifier">the_object</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">the_object</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">object</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">the_object</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">object_</span><span class="special">(</span><span class="identifier">the_object</span><span class="special">),</span> <span class="identifier">queries_</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">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">shared_instance</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">delete</span> <span class="identifier">object_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Contracts for volatile member function.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span><span class="special">)</span> <span class="special">(</span><span class="identifier">object</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="keyword">volatile</span>
<span class="comment">// No preconditions nor postconditions for this example but when</span>
<span class="comment">// present object is `const volatile` within assertions.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">queries_</span><span class="special">++;</span>
<span class="keyword">return</span> <span class="identifier">object_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">queries</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">queries_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="identifier">object_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">mutable</span> <span class="keyword">int</span> <span class="identifier">queries_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p><p>
As usual, contracts are checked in constant-correct context therefore only
<code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code>
members can be accessed from volatile class invariants, preconditions, and
postconditions.
</p></div><div class="section" title="Operators"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.operators"></a><a class="link" href="#contract__.advanced_topics.operators" title="Operators">Operators</a></h3></div></div></div><p>
It is possible to program contracts for operators (both member function operators
and free function operators). The operator name must be specified using the
following syntax when passed to the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a></code>, and
<code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code> macros:
</p><pre class="programlisting"><span class="keyword">operator</span><span class="special">(</span><span class="emphasis"><em>symbol</em></span><span class="special">)(</span><span class="emphasis"><em>arbitrary-alphanumeric-name</em></span><span class="special">)</span>
</pre><p>
The first parameter is the usual operator symbol (<code class="computeroutput"><span class="special">==</span></code>,
<code class="computeroutput"><span class="special">+</span></code>, etc) the second parameter
is an arbitrary but alphanumeric name (<code class="computeroutput"><span class="identifier">equal</span></code>,
<code class="computeroutput"><span class="identifier">plus</span></code>, etc). The operator
<code class="computeroutput"><span class="keyword">new</span></code>, the operator <code class="computeroutput"><span class="keyword">delete</span></code>, and implicit type conversion operators
for fundamental types containing no symbol can also be specified simply as:
</p><pre class="programlisting"><span class="keyword">operator</span> <span class="keyword">new</span>
<span class="keyword">operator</span> <span class="keyword">delete</span>
<span class="keyword">operator</span> <span class="emphasis"><em>fundamental-type-without-symbols</em></span>
</pre><p>
The comma operator must be specified as: <sup>[<a name="contract__.advanced_topics.operators.f0" href="#ftn.contract__.advanced_topics.operators.f0" class="footnote">48</a>]</sup>
</p><pre class="programlisting"><span class="keyword">operator</span> <span class="identifier">comma</span>
</pre><p>
For example (see also <a class="ulink" href="../../example/contracts/member_operator_string.cpp" target="_top"><code class="literal">member_operator_string.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">string</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span>
<span class="keyword">static</span> <span class="keyword">class</span><span class="special">(</span> <span class="identifier">pointers</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">arrays</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">int</span> <span class="identifier">pointers</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">int</span> <span class="identifier">arrays</span><span class="special">;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="identifier">c_str</span><span class="special">,</span> <span class="keyword">default</span><span class="special">(</span><span class="string">""</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">string_</span><span class="special">(</span><span class="identifier">c_str</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(~</span><span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Symbolic operators: `(==)(equal)`, `(())(call)`, etc.</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">(==)(</span><span class="identifier">equal</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">string_</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">string_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Implicit type conversion operator (keyword type).</span>
<span class="keyword">public</span> <span class="keyword">operator</span> <span class="keyword">char</span> <span class="keyword">const</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">string_</span><span class="special">[</span><span class="number">0</span><span class="special">];</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Implicit type conversion operator (symbolic type).</span>
<span class="keyword">public</span> <span class="keyword">operator</span><span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)(</span><span class="identifier">char_const_ptr</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">string_</span><span class="special">.</span><span class="identifier">c_str</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Implicit type conversion operator (type with commas).</span>
<span class="keyword">public</span> <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">Allocator</span> <span class="special">)</span>
<span class="keyword">operator</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;)(</span><span class="identifier">std_vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="identifier">string_</span><span class="special">.</span><span class="identifier">size</span><span class="special">());</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">string_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">v</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">string_</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="keyword">return</span> <span class="identifier">v</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Comma operator (use `comma` to diff. from above).</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">string</span><span class="special">&amp;)</span> <span class="keyword">operator</span> <span class="identifier">comma</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">string_</span> <span class="special">+=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">string_</span><span class="special">;</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// All memory operators (new, delete, new[], and delete[]) must be</span>
<span class="comment">// explicitly `static` (because pp can't inspect new[] and delete[] that</span>
<span class="comment">// could be any symbolic operator like ==, +, etc).</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="special">(</span><span class="keyword">void</span><span class="special">*)</span> <span class="keyword">operator</span> <span class="keyword">new</span> <span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">size</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">void</span><span class="special">*</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">malloc</span><span class="special">(</span><span class="identifier">size</span><span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">p</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span><span class="special">();</span>
<span class="identifier">pointers</span><span class="special">++;</span>
<span class="keyword">return</span> <span class="identifier">p</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="keyword">void</span> <span class="keyword">operator</span> <span class="keyword">delete</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">void</span><span class="special">*)</span> <span class="identifier">pointer</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">pointer</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">free</span><span class="special">(</span><span class="identifier">pointer</span><span class="special">);</span>
<span class="identifier">pointers</span><span class="special">--;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="special">(</span><span class="keyword">void</span><span class="special">*)</span> <span class="keyword">operator</span><span class="special">(</span><span class="keyword">new</span><span class="special">[])(</span><span class="identifier">new_array</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">size</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">void</span><span class="special">*</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">malloc</span><span class="special">(</span><span class="identifier">size</span><span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">a</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">throw</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span><span class="special">();</span>
<span class="identifier">arrays</span><span class="special">++;</span>
<span class="keyword">return</span> <span class="identifier">a</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">(</span><span class="keyword">delete</span><span class="special">[])(</span><span class="identifier">delete_array</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">void</span><span class="special">*)</span> <span class="identifier">array</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">array</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">free</span><span class="special">(</span><span class="identifier">array</span><span class="special">);</span>
<span class="identifier">arrays</span><span class="special">--;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">string_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">string</span><span class="special">::</span><span class="identifier">pointers</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">int</span> <span class="identifier">string</span><span class="special">::</span><span class="identifier">arrays</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
</pre><p>
</p><p>
The memory operators <code class="computeroutput"><span class="keyword">new</span></code>, <code class="computeroutput"><span class="keyword">delete</span></code>, <code class="computeroutput"><span class="keyword">new</span><span class="special">[]</span></code>, and <code class="computeroutput"><span class="keyword">delete</span><span class="special">[]</span></code> must always be specified <code class="computeroutput"><span class="keyword">static</span></code> when they are programmed as member
function operators. <sup>[<a name="contract__.advanced_topics.operators.f1" href="#ftn.contract__.advanced_topics.operators.f1" class="footnote">49</a>]</sup>
</p><p>
Free function operators are programmed using the same syntax for the operator
names.
</p></div><div class="section" title="Nested Classes"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.nested_classes"></a><a class="link" href="#contract__.advanced_topics.nested_classes" title="Nested Classes">Nested Classes</a></h3></div></div></div><p>
It is possible to program contracts for nested classes noting that:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
The access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> must be specified for contracted
members and therefore also for nested classes.
</li><li class="listitem">
The <code class="computeroutput"><span class="identifier">_TPL</span></code> macros must
be used within templates so the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_TPL" title="Macro CONTRACT_CLASS_TPL">CONTRACT_CLASS_TPL</a></code>
macro needs to be used when programming a class nested within a class
template.
</li></ol></div><p>
For example (see also <a class="ulink" href="../../example/contracts/nested_class_bitset.cpp" target="_top"><code class="literal">nested_class_bitset.cpp</code></a> and
the <a class="link" href="#contract__.concepts" title="Concepts">Concepts</a> section):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Enclosing class.</span>
<span class="keyword">template</span><span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">N</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">bitset</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="keyword">static</span> <span class="keyword">class</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">N</span> <span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CLASS_TPL</span><span class="special">(</span> <span class="comment">// Nested class.</span>
<span class="keyword">public</span> <span class="keyword">class</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">bitptr_</span> <span class="special">)</span>
<span class="keyword">friend</span> <span class="keyword">class</span> <span class="identifier">bitset</span><span class="special">;</span>
<span class="identifier">CONTRACT_CLASS_TPL</span><span class="special">(</span> <span class="comment">// Nested (twice) class template with concepts.</span>
<span class="keyword">private</span> <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="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">DefaultConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">bit</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">bit</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">initialize</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="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">from_bool</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">to_bool</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="identifier">value_</span> <span class="special">=</span> <span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">to_bool</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">private</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">bitptr_</span><span class="special">-&gt;</span><span class="identifier">to_bool</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span>
<span class="identifier">bitptr_</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">bit</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="keyword">new</span> <span class="identifier">bit</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;()))</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(~</span><span class="identifier">reference</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">operator</span> <span class="keyword">bool</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">bitptr_</span><span class="special">-&gt;</span><span class="identifier">to_bool</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(=)(</span><span class="identifier">assign</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">bool</span> <span class="keyword">const</span> <span class="identifier">bit_value</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">bitptr_</span><span class="special">-&gt;</span><span class="identifier">from_bool</span><span class="special">(</span><span class="identifier">bit_value</span><span class="special">);</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">bit</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">bitptr_</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">N</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">bitset_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="identifier">size_t</span> <span class="special">(</span><span class="identifier">size</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">N</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">reference</span> <span class="identifier">bitset_</span><span class="special">[</span><span class="identifier">N</span><span class="special">];</span>
<span class="special">};</span>
</pre><p>
</p></div><div class="section" title="Friends"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.friends"></a><a class="link" href="#contract__.advanced_topics.friends" title="Friends">Friends</a></h3></div></div></div><p>
It is possible to program contracts for friend classes and friend functions.
Classes can be declared friends and later contracted using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> macro as usual:
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Not even necessary to contract this class.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">x</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="keyword">friend</span> <span class="keyword">class</span> <span class="identifier">y</span> <span class="special">;</span>
<span class="comment">// ...</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">y</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="comment">// ...</span>
<span class="special">};</span>
</pre><p>
Friend functions that are declared and defined within the enclosing class
use the <code class="computeroutput"><span class="keyword">friend</span></code> keyword within
the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macro
(note that the access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> is optional in this case because these
friend functions are not member functions). Friend functions that are either
forward declared friends or that are defined friends within the enclosing
class, must use the <code class="computeroutput"><a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a></code>
macro. For example (see also <a class="ulink" href="../../example/contracts/friend_counter.cpp" target="_top"><code class="literal">friend_counter.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Not even necessary to contract this class.</span>
<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="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">CopyConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">);</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Friend (contracted declaration and definition).</span>
<span class="keyword">public</span> <span class="keyword">friend</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(/)(</span><span class="identifier">div</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">counter</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">right</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// Strictly positive, cannot be zero.</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">*</span> <span class="identifier">right</span> <span class="special">==</span> <span class="identifier">left</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="keyword">return</span> <span class="identifier">counter</span><span class="special">(</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">/</span> <span class="identifier">right</span><span class="special">);</span>
<span class="special">}</span>
<span class="comment">// Friend forward declaration (contracted declaration and definition below).</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">&gt;</span>
<span class="keyword">friend</span> <span class="keyword">bool</span> <span class="identifier">CONTRACT_FREE_BODY</span><span class="special">(</span><span class="keyword">operator</span><span class="special">(==)(</span><span class="identifier">equal</span><span class="special">))</span> <span class="special">(</span> <span class="comment">// Use BODY.</span>
<span class="identifier">counter</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">left</span><span class="special">,</span> <span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span> <span class="special">;</span>
<span class="comment">// NOTE: Forward friend template instantiations give internal MSVC error.</span>
<span class="preprocessor">#if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_MSVC</span><span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">defined</span><span class="special">(</span><span class="identifier">CONTRACT_CONFIG_NO_POSTCONDITIONS</span><span class="special">)</span>
<span class="comment">// Friend definition (contracted declaration below).</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">friend</span> <span class="identifier">counter</span> <span class="identifier">CONTRACT_FREE_BODY</span><span class="special">(</span><span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">mult</span><span class="special">))</span> <span class="special">(</span> <span class="comment">// Use BODY.</span>
<span class="identifier">counter</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">left</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">counter</span><span class="special">(</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">*</span> <span class="identifier">right</span><span class="special">);</span> <span class="comment">// Contract checked `right &gt;=0` .</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Public constructor gets next counter value.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">value_</span><span class="special">(</span><span class="identifier">next_value_</span><span class="special">++)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Private constructor.</span>
<span class="keyword">private</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">a_value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">a_value</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a_value</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">value_</span><span class="special">(</span><span class="identifier">a_value</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">value</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">next_value_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="identifier">T</span> <span class="identifier">counter</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">next_value_</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">();</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">)</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">(==)(</span><span class="identifier">equal</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span> <span class="special">(</span><span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">right</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#if</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_MSVC</span><span class="special">)</span> <span class="special">&amp;&amp;</span> <span class="special">!</span><span class="identifier">defined</span><span class="special">(</span><span class="identifier">CONTRACT_CONFIG_NO_POSTCONDITIONS</span><span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="special">(</span><span class="identifier">counter</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;)</span> <span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">mult</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">right</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">*</span> <span class="identifier">right</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="preprocessor">#endif</span>
</pre><p>
</p><p>
The class enclosing the friend declarations might or might not be contracted.
</p></div><div class="section" title="Template Specializations"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.template_specializations"></a><a class="link" href="#contract__.advanced_topics.template_specializations" title="Template Specializations">Template
Specializations</a></h3></div></div></div><p>
It is possible to program contracts for class template specializations. The
generic class template might or might not be contracted (see also <a class="ulink" href="../../example/contracts/template_specializations_vector.cpp" target="_top"><code class="literal">template_specializations_vector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Not even necessary to contract this template.</span>
<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">Allocator</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
The template specialization types follow the class name as usual but they
are wrapped within round parenthesis <code class="computeroutput"><span class="special">(</span>
<span class="keyword">bool</span><span class="special">,</span> <span class="identifier">Allocator</span> <span class="special">)</span></code>
instead than angular parenthesis <code class="computeroutput"><span class="special">&lt;</span>
<span class="keyword">bool</span><span class="special">,</span> <span class="identifier">Allocator</span> <span class="special">&gt;</span></code>
as in the following partial specialization:
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Template specialization (one template parameter).</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">bool</span><span class="special">,</span> <span class="identifier">Allocator</span> <span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
The syntax <code class="computeroutput"><span class="keyword">template</span><span class="special">(</span>
<span class="keyword">void</span> <span class="special">)</span></code>
must be used instead of <code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span> <span class="special">&gt;</span></code>
to indicate explicit specializations:
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Template specialization (no template parameter).</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">bool</span> <span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// ...</span>
</pre><p>
</p></div><div class="section" title="Exception Specifications and Function-Try Blocks"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.exception_specifications_and_function_try_blocks"></a><a class="link" href="#contract__.advanced_topics.exception_specifications_and_function_try_blocks" title="Exception Specifications and Function-Try Blocks">Exception
Specifications and Function-Try Blocks</a></h3></div></div></div><p>
It is possible to program exception specifications and function-try blocks
for constructors, destructors, member functions, and free functions with
contracts. Exception specifications are part of the function declarations
therefore they are programmed within the contract macros but the special
syntax <code class="computeroutput"><span class="keyword">throw</span><span class="special">(</span>
<span class="keyword">void</span> <span class="special">)</span></code>
must be used instead of <code class="computeroutput"><span class="keyword">throw</span><span class="special">(</span> <span class="special">)</span></code> to specify
that no exception is thrown:
</p><pre class="programlisting"><span class="keyword">throw</span><span class="special">(</span> <span class="emphasis"><em>exception-type1</em></span><span class="special">,</span> <span class="emphasis"><em>exception-type2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span> <span class="comment">// As usual.</span>
<span class="keyword">throw</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Instead of `throw( )`.</span>
</pre><p>
Function-try blocks are part of the function definition so they are normally
programmed outside the contract macros. However, for constructors with member
initializers, the member initializers must be programmed within the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code> macro and therefore
also the function-try blocks must be programmed within the macro using the
following syntax:
</p><pre class="programlisting"><span class="keyword">try</span> <span class="identifier">initialize</span><span class="special">(</span> <span class="emphasis"><em>initializer1</em></span><span class="special">,</span> <span class="emphasis"><em>initializer2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
<span class="keyword">catch</span><span class="special">(</span><span class="emphasis"><em>exception-declaration1</em></span><span class="special">)</span> <span class="special">(</span> <span class="emphasis"><em>instruction1</em></span><span class="special">;</span> <span class="emphasis"><em>instruction2</em></span><span class="special">;</span> <span class="special">...</span> <span class="special">)</span>
<span class="keyword">catch</span><span class="special">(</span><span class="emphasis"><em>exception-declaration2</em></span><span class="special">)</span> <span class="special">(</span> <span class="emphasis"><em>instruction1</em></span><span class="special">;</span> <span class="emphasis"><em>instruction2</em></span><span class="special">;</span> <span class="special">...</span> <span class="special">)</span>
<span class="keyword">catch</span><span class="special">(...)</span> <span class="special">(</span> <span class="emphasis"><em>instruction1</em></span><span class="special">;</span> <span class="emphasis"><em>instruction2</em></span><span class="special">;</span> <span class="special">...</span> <span class="special">)</span>
</pre><p>
As usual, only one catch statement must be specified and the other catch
statements are optional plus <code class="computeroutput"><span class="keyword">catch</span><span class="special">(...)</span></code> can be used to catch all exceptions.
Note however that round parenthesis <code class="computeroutput"><span class="special">(</span>
<span class="special">...</span> <span class="special">)</span></code>
are used instead of curly parenthesis <code class="computeroutput"><span class="special">{</span>
<span class="special">...</span> <span class="special">}</span></code>
to wrap the catch statement instructions (then the catch instructions are
programmed with the usual syntax and separated by semicolons <code class="computeroutput"><span class="special">;</span></code>). (The maximum number of catch statements
that can be programmed for constructor-try blocks is specified by the <code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES" title="Macro CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES">CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES</a></code>
macro.)
</p><p>
In the following example the constructor uses a function-try block to throw
only <code class="computeroutput"><span class="identifier">out_of_memory</span></code> and <code class="computeroutput"><span class="identifier">error</span></code> exceptions while the destructor uses
exception specifications to throw no exception (see also <a class="ulink" href="../../example/contracts/exception_array.cpp" target="_top"><code class="literal">exception_array.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">array</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">struct</span> <span class="identifier">out_of_memory</span> <span class="special">{};</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">struct</span> <span class="identifier">error</span> <span class="special">{};</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">array</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">size_t</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="comment">// Function try-blocks are programmed within the macros only for</span>
<span class="comment">// constructors with member initializers otherwise they are</span>
<span class="comment">// programmed with the body definitions and outside the macros.</span>
<span class="keyword">try</span> <span class="identifier">initialize</span><span class="special">(</span> <span class="comment">// Try block for constructor initializers and body.</span>
<span class="identifier">data_</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">count</span><span class="special">]),</span>
<span class="identifier">size_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span>
<span class="comment">// Use `BOOST_IDENTITY_TYPE` if the exception type has unwrapped</span>
<span class="comment">// commas or leading symbols.</span>
<span class="special">)</span> <span class="keyword">catch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span><span class="special">&amp;)</span> <span class="special">(</span>
<span class="keyword">throw</span> <span class="identifier">out_of_memory</span><span class="special">();</span>
<span class="special">)</span> <span class="keyword">catch</span><span class="special">(...)</span> <span class="special">(</span>
<span class="keyword">throw</span> <span class="identifier">error</span><span class="special">();</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">array</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">throw</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Throw nothing.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
(The <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span></code>
macro can be used to wrap the catch statement exception declaration types
if they contain unwrapped commas.)
</p><p>
Exception specifications and function-try blocks apply only to exceptions
thrown by the function body and not to exceptions thrown by the contracts
themselves (if any) and by the contract checking code generated by this library
macros. <sup>[<a name="contract__.advanced_topics.exception_specifications_and_function_try_blocks.f0" href="#ftn.contract__.advanced_topics.exception_specifications_and_function_try_blocks.f0" class="footnote">50</a>]</sup>
</p></div><div class="section" title="Specifying Types (no Boost.Typeof)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.specifying_types__no_boost_typeof_"></a><a class="link" href="#contract__.advanced_topics.specifying_types__no_boost_typeof_" title="Specifying Types (no Boost.Typeof)">Specifying
Types (no Boost.Typeof)</a></h3></div></div></div><p>
This library uses <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
to automatically deduces postcondition old value types and constant assertion
variable types. If programmers do not want the library to use <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
they can explicitly specify these types.
</p><p>
The types of postcondition old values are specified instead of using <code class="computeroutput"><span class="keyword">auto</span></code> and they must be wrapped within round
parenthesis unless they are fundamental types containing no symbol (these
must match the type of the specified old-of expressions):
</p><pre class="programlisting"><span class="special">(</span><span class="emphasis"><em>type</em></span><span class="special">)</span> <span class="emphasis"><em>variable</em></span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="emphasis"><em>oldof-expression</em></span>
</pre><p>
The types of constant assertion variables are specified just before each
variable name and they also must be wrapped within round parenthesis unless
they are fundamental types containing no symbol:
</p><pre class="programlisting"><span class="keyword">const</span><span class="special">(</span> <span class="special">(</span><span class="emphasis"><em>type1</em></span><span class="special">)</span> <span class="emphasis"><em>variable1</em></span><span class="special">,</span> <span class="special">(</span><span class="emphasis"><em>type2</em></span><span class="special">)</span> <span class="emphasis"><em>variable2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span> <span class="emphasis"><em>boolean-expression</em></span>
</pre><p>
For example (see also <a class="ulink" href="../../example/contracts/typed_counter.cpp" target="_top"><code class="literal">typed_counter.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">unsigned</span> <span class="identifier">value</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">next</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="comment">// Explicit types so no Boost.Typeof.</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">unsigned</span> <span class="keyword">const</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span><span class="special">,</span>
<span class="keyword">const</span><span class="special">(</span> <span class="keyword">unsigned</span> <span class="identifier">value</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">const</span> <span class="identifier">old_value</span> <span class="special">)</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="keyword">int</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="keyword">return</span> <span class="special">++</span><span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">unsigned</span> <span class="identifier">counter</span><span class="special">::</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
</pre><p>
</p><p>
Note that postcondition result values are always specified using <code class="computeroutput"><span class="keyword">auto</span></code>:
</p><pre class="programlisting"><span class="keyword">auto</span> <span class="emphasis"><em>result-variable</em></span> <span class="special">=</span> <span class="keyword">return</span>
</pre><p>
This is because the function return type is know by the library as specified
in the function declaration within the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
macro. Therefore, the postcondition result value type is never explicitly
specified by programmers (but <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
is never used to deduce it).
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
It is recommended to not specify these types explicitly and let the library
internally use <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
to deduce them because the library syntax is more readable without the
explicit types. However, all types must be properly registered with <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
as usual in order to use type-of emulation mode on <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
compilers that do not support native type-of (see <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
for more information).
</p></td></tr></table></div></div><div class="section" title="Block Invariants and Loop Variants"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.block_invariants_and_loop_variants"></a><a class="link" href="#contract__.advanced_topics.block_invariants_and_loop_variants" title="Block Invariants and Loop Variants">Block
Invariants and Loop Variants</a></h3></div></div></div><p>
<span class="emphasis"><em>Block invariants</em></span> can be used anywhere within the function
body and they are used to assert correctness conditions of the implementation
(very much like <code class="computeroutput"><span class="identifier">assert</span></code>).
They are programmed specifying a list of assertions to the <code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT" title="Macro CONTRACT_BLOCK_INVARIANT">CONTRACT_BLOCK_INVARIANT</a></code>
macro (including static, constant, and select assertions):
</p><pre class="programlisting"><span class="identifier">CONTRACT_BLOCK_INVARIANT</span><span class="special">(</span> <span class="emphasis"><em>assertion1</em></span><span class="special">,</span> <span class="emphasis"><em>assertion2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
</pre><p>
When block invariants are used within a loop, they are also called <span class="emphasis"><em>loop
invariants</em></span> (e.g., <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
uses this terminology).
</p><p>
Furthermore, this library allows to specify <a class="ulink" href="http://en.wikipedia.org/wiki/Loop_variant" target="_top"><span class="emphasis"><em>loop
variants</em></span></a>. A loop variant is a non-negative monotonically
decreasing number that is updated at each iteration of the loop. The specified
loop variant expression is calculated by this library at each iteration of
the loop and it is automatically asserted to be non-negative (<code class="computeroutput"><span class="special">&gt;=</span> <span class="number">0</span></code>) and
to decrease monotonically from the previous loop iteration. Because the loop
variant monotonically decreases and it cannot be smaller than zero, either
the loop terminates or one of the two library assertions will eventually
fail in which case the library will call the <code class="computeroutput"><a class="link" href="#contract.loop_variant_broken" title="Function loop_variant_broken">contract::loop_variant_broken</a></code>
handler therefore detecting and stopping infinite loops. Each given loop
can only have one variant which is specified using the <code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT" title="Macro CONTRACT_LOOP_VARIANT">CONTRACT_LOOP_VARIANT</a></code>
macro. The enclosing loop (<code class="computeroutput"><span class="keyword">while</span></code>,
<code class="computeroutput"><span class="keyword">for</span></code>, <code class="computeroutput"><span class="keyword">do</span></code>,
etc) must be declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_LOOP" title="Macro CONTRACT_LOOP">CONTRACT_LOOP</a></code>
macro:
</p><pre class="programlisting"><span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="emphasis"><em>loop-declaration</em></span> <span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_LOOP_VARIANT</span><span class="special">(</span> <span class="emphasis"><em>non-negative-monotonically-decreasing-expression</em></span> <span class="special">)</span>
<span class="special">...</span>
<span class="special">}</span>
</pre><p>
Note that the library cannot automatically make constant any of the variables
within the function body therefore constant block invariant assertions and
constant loop variant expressions should be used by programmers if they want
to enforce constant-correctness for block invariants and loop variants.
</p><p>
The following example uses a loop to calculate the <a class="ulink" href="http://en.wikipedia.org/wiki/Greatest_common_divisor" target="_top">Greatest
Common Divisor (GCD)</a> of two integral numbers (see also <a class="ulink" href="../../example/contracts/blockinv_loopvar_gcd.cpp" target="_top"><code class="literal">blockinv_loopvar_gcd.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">gcd</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">a</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">b</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">static_assert</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">"integral type"</span><span class="special">),</span>
<span class="identifier">a</span> <span class="special">!=</span> <span class="number">0</span><span class="special">,</span>
<span class="identifier">b</span> <span class="special">!=</span> <span class="number">0</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">&lt;=</span> <span class="identifier">a</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">&lt;=</span> <span class="identifier">b</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">T</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">b</span><span class="special">;</span>
<span class="comment">// Block invariant assert conditions within body,</span>
<span class="identifier">CONTRACT_BLOCK_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">a</span> <span class="special">)</span> <span class="identifier">x</span> <span class="special">==</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">b</span> <span class="special">)</span> <span class="identifier">y</span> <span class="special">==</span> <span class="identifier">b</span> <span class="special">)</span>
<span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">x</span> <span class="special">!=</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">// Define a loop with variants (below).</span>
<span class="comment">// Block invariant for loops (i.e., loop invariants).</span>
<span class="identifier">CONTRACT_BLOCK_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="identifier">x</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">,</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">y</span> <span class="special">)</span> <span class="identifier">y</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span>
<span class="comment">// Loop variant checked to be non-negative and monotonically decreasing.</span>
<span class="identifier">CONTRACT_LOOP_VARIANT_TPL</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">x</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">max</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">)</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">x</span> <span class="special">&gt;</span> <span class="identifier">y</span><span class="special">)</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">x</span> <span class="special">-</span> <span class="identifier">y</span><span class="special">;</span>
<span class="keyword">else</span> <span class="identifier">y</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="keyword">return</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p><p>
<a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
supports loop variants but <a class="link" href="#N1962_anchor">[N1962]</a> does
not. Loop variants might not be very useful especially if <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/foreach" target="_top">Boost.Foreach</a>
or similar constructs are used to ensure loop termination.
</p></div><div class="section" title="Contract Broken Handlers (Throw on Failure)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.advanced_topics.contract_broken_handlers__throw_on_failure_"></a><a class="link" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_" title="Contract Broken Handlers (Throw on Failure)">Contract
Broken Handlers (Throw on Failure)</a></h3></div></div></div><p>
When a contract assertion fails, this library prints a message on the standard
error <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span></code> and it terminates the program calling
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span></code>. Programmers can change this
behavior customizing the actions that the library takes on contract assertion
failure by setting the contract broken handler functions. By default the
library terminates the program because a contract failure indicates that
the program is in an invalid state that programmers specified it should never
happen (so the only sensible assumption is that the program execution should
not continue). However, in some cases programmers might need to handle even
such catastrophic failures by executing some fail-safe code instead of terminating
the program and that can be done customizing the contract broken handlers.
</p><p>
The library functions <code class="computeroutput"><a class="link" href="#contract.set_precondition_broken">contract::set_precondition_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.set_postcondition_broken">contract::set_postcondition_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.set_class_invariant_broken">contract::set_class_invariant_broken</a></code>,
<code class="computeroutput"><a class="link" href="#contract.set_block_invariant_broken">contract::set_block_invariant_broken</a></code>,
and <code class="computeroutput"><a class="link" href="#contract.set_loop_variant_broken">contract::set_loop_variant_broken</a></code>
can be used to customize the action to taken in case of precondition, postcondition,
class invariant, block invariant, and loop variant failure respectively.
Furthermore, class invariants are checked at entry, at normal exit, and at
exit but when exceptions are thrown so more granular handlers can be set
for each of these cases using <code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485380">contract::set_class_invariant_broken_on_entry</a></code>,
<code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485458">contract::set_class_invariant_broken_on_exit</a></code>,
and <code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485536">contract::set_class_invariant_broken_on_throw</a></code>
(using <code class="computeroutput"><a class="link" href="#contract.set_class_invariant_broken">contract::set_class_invariant_broken</a></code>
is equivalent to setting all these class invariant broken handles to the
same handler). <sup>[<a name="contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f0" href="#ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f0" class="footnote">51</a>]</sup>
</p><p>
This library passes a parameter of type <code class="computeroutput"><a class="link" href="#contract.from" title="Type from">contract::from</a></code>
to the contract broken handler functions indicating the context that failed
the contract assertion (e.g., this parameter will be set to <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">FROM_DESTRUCTOR</span></code> if the contract assertion
failed from a destructor): <sup>[<a name="contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f1" href="#ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f1" class="footnote">52</a>]</sup>
</p><pre class="programlisting"><span class="keyword">void</span> <span class="emphasis"><em>contract-broken-handler</em></span> <span class="special">(</span> <span class="identifier">contract</span><span class="special">::</span><span class="identifier">from</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">context</span> <span class="special">)</span>
</pre><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
In order to comply with the STL exception safety requirements, destructors
should never throw. Therefore, even if programmers customize the contract
broken handlers to throw exceptions instead of terminating, the handlers
should never throw when contract assertions fail from a destructor (and
the <code class="computeroutput"><a class="link" href="#contract.from" title="Type from">contract::from</a></code> parameter
can be used to discriminate this case).
</p></td></tr></table></div><p>
The contract broken handlers are always invoked with an active exception
that refers to the exception that failed the contract: <sup>[<a name="contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f2" href="#ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f2" class="footnote">53</a>]</sup>
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Either an exception that was explicitly thrown by the user from the contract
(e.g. <code class="computeroutput"><span class="identifier">not_a_number</span></code> in
the example blow).
</li><li class="listitem">
Or, an exception that was thrown <span class="quote">&#8220;<span class="quote">behind the scene</span>&#8221;</span> while
evaluating a contract assertion (e.g., the assertion calls an STL algorithm
and that throws <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code>).
</li><li class="listitem">
Or, an exception automatically thrown by this library in case a contract
assertion is evaluated to be false (these exceptions are always <code class="computeroutput"><a class="link" href="#contract.broken" title="Class broken">contract::broken</a></code> objects and they
contained detailed information about the contract assertion that was
evaluated to be false: file name, line number, assertion number, and
assertion code). <sup>[<a name="contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f3" href="#ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f3" class="footnote">54</a>]</sup>
</li></ol></div><p>
In all these cases the contract assertion is considered failed because it
was not evaluated to be true (and that is the case not only for assertions
that are evaluated to be false but also for assertions that throw exceptions
while being evaluated). <sup>[<a name="contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f4" href="#ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f4" class="footnote">55</a>]</sup> The customized contract broken handlers can re-throw the active
exception and catch it so to inspect it for logging or for any other customized
behaviour that might need to be implemented by the programmers.
</p><p>
The following example customizes the contract broken handlers to throw exceptions
(both user-defined exceptions like <code class="computeroutput"><span class="identifier">not_a_number</span></code>
and the <code class="computeroutput"><a class="link" href="#contract.broken" title="Class broken">contract::broken</a></code> exception
that the library automatically throws in case of a contract assertion failure).
However, the customized handlers never throw from within a destructor to
comply with STL exception safety requirements (see also <a class="ulink" href="../../example/contracts/broken_handler_sqrt.cpp" target="_top"><code class="literal">broken_handler_sqrt.cpp</code></a>):
<sup>[<a name="contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f5" href="#ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f5" class="footnote">56</a>]</sup>
</p><p>
</p><pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">not_a_number</span> <span class="special">{};</span> <span class="comment">// User defined exception.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">double</span> <span class="special">(</span><span class="identifier">sqrt</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">double</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">x</span> <span class="special">&gt;=</span> <span class="number">0.0</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">not_a_number</span><span class="special">()</span> <span class="comment">// Throw user exception.</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">root</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">root</span> <span class="special">*</span> <span class="identifier">root</span> <span class="special">==</span> <span class="identifier">x</span> <span class="comment">// Failure throws `contract::broken` exception.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="number">0.0</span><span class="special">;</span> <span class="comment">// Intentionally incorrect to fail postcondition.</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">throwing_handler</span> <span class="special">(</span> <span class="identifier">contract</span><span class="special">::</span><span class="identifier">from</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">context</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// Failure handlers always called with active exception that failed the</span>
<span class="comment">// contract, so re-throw it to catch it below for logging.</span>
<span class="keyword">try</span> <span class="special">{</span>
<span class="keyword">throw</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">catch</span><span class="special">(</span><span class="identifier">contract</span><span class="special">::</span><span class="identifier">broken</span><span class="special">&amp;</span> <span class="identifier">failure</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="identifier">failure</span><span class="special">.</span><span class="identifier">file_name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"("</span> <span class="special">&lt;&lt;</span> <span class="identifier">failure</span><span class="special">.</span><span class="identifier">line_number</span><span class="special">()</span> <span class="special">&lt;&lt;</span>
<span class="string">"): contract assertion \""</span> <span class="special">&lt;&lt;</span> <span class="identifier">failure</span><span class="special">.</span><span class="identifier">assertion_code</span><span class="special">()</span> <span class="special">&lt;&lt;</span>
<span class="string">"\" failed "</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">catch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">failure</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"contract failed: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">failure</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">catch</span><span class="special">(...)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"contract failed with unknown error"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Cannot throw from destructors to comply with STL exception safety,</span>
<span class="comment">// otherwise re-throw active exception that failed the contract.</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">context</span> <span class="special">==</span> <span class="identifier">contract</span><span class="special">::</span><span class="identifier">FROM_DESTRUCTOR</span><span class="special">)</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"Ignoring destructor contract failure (probably "</span>
<span class="special">&lt;&lt;</span> <span class="string">"something bad has happened)"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">else</span> <span class="keyword">throw</span><span class="special">;</span> <span class="comment">// Never terminates.</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// Customize contract broken handlers to throw exceptions instead of</span>
<span class="comment">// terminating the program (default).</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">set_precondition_broken</span><span class="special">(&amp;</span><span class="identifier">throwing_handler</span><span class="special">);</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">set_postcondition_broken</span><span class="special">(&amp;</span><span class="identifier">throwing_handler</span><span class="special">);</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">CONTRACT_CONFIG_NO_PRECONDITIONS</span>
<span class="keyword">bool</span> <span class="identifier">pre</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
<span class="keyword">try</span> <span class="special">{</span>
<span class="identifier">sqrt</span><span class="special">(-</span><span class="number">1.0</span><span class="special">);</span> <span class="comment">// Fails precondition.</span>
<span class="special">}</span> <span class="keyword">catch</span><span class="special">(</span><span class="identifier">not_a_number</span><span class="special">&amp;)</span> <span class="special">{</span>
<span class="identifier">pre</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">clog</span> <span class="special">&lt;&lt;</span> <span class="string">"Ignoring not-a-number exception"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">pre</span><span class="special">);</span>
<span class="preprocessor">#endif</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">CONTRACT_CONFIG_NO_POSTCONDITIONS</span>
<span class="keyword">bool</span> <span class="identifier">post</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
<span class="keyword">try</span> <span class="special">{</span>
<span class="identifier">sqrt</span><span class="special">(</span><span class="number">4.0</span><span class="special">);</span> <span class="comment">// Fails postcondition.</span>
<span class="special">}</span> <span class="keyword">catch</span><span class="special">(...)</span> <span class="special">{</span>
<span class="identifier">post</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">clog</span> <span class="special">&lt;&lt;</span> <span class="string">"Unable to calculate square root"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">post</span><span class="special">);</span>
<span class="preprocessor">#endif</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p><p>
Note how the ternary operator <code class="computeroutput"><span class="special">:?</span></code>
can be used to program assertions that throw exceptions on failure:
</p><pre class="programlisting"><span class="identifier">x</span> <span class="special">&gt;=</span> <span class="number">0.0</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">not_a_number</span>
</pre><p>
Then the contract broken handlers are customized to propagate the exceptions
instead of handling them by calling <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span></code>
(default behaviour).
</p><p>
See also <a class="ulink" href="../../example/contracts/contract_failure.cpp" target="_top"><code class="literal">contract_failure.cpp</code></a> for
a more complex example that redefines the contract broken handlers to throw
exceptions in order to automatically check that the correct contract broken
handlers are called when assertions fail in accordance with the call semantics
explained in the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview">Contract
Programming Overview</a> section.
</p></div></div><div class="section" title="Virtual Specifiers"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.virtual_specifiers"></a><a class="link" href="#contract__.virtual_specifiers" title="Virtual Specifiers">Virtual Specifiers</a></h2></div></div></div><p>
This section explains how to use this library to program virtual specifiers
<code class="computeroutput"><span class="identifier">final</span></code>, <code class="computeroutput"><span class="identifier">override</span></code>,
and <code class="computeroutput"><span class="keyword">new</span></code>. Virtual specifiers are
part of the program specifications because they enforce inheritance constraints
at compile-time and therefore they are within the scope of this library.
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
This library implements virtual specifiers for <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
and without using any <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
feature. <sup>[<a name="contract__.virtual_specifiers.f0" href="#ftn.contract__.virtual_specifiers.f0" class="footnote">57</a>]</sup> Obviously, virtual specifiers are supported only if both the
base and derived classes and member functions in question are declared using
this library macros (otherwise this library has no control over usual C++
declarations).
</p></td></tr></table></div><p>
The examples presented in this section are rather simple (and they do not define
virtual destructors for brevity). These examples only aim to illustrate the
syntax of this library virtual specifiers and not to make a case about the
utility of these specifiers. Virtual specifiers were adopted by <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
and in some form are part of other languages like <a class="ulink" href="http://en.wikipedia.org/wiki/Java_(programming_language)" target="_top">Java</a>,
programmers can refer to the web and to the <a class="link" href="#contract__.examples" title="Examples">Examples</a>
section for more interesting examples.
</p><div class="section" title="Final Classes"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.virtual_specifiers.final_classes"></a><a class="link" href="#contract__.virtual_specifiers.final_classes" title="Final Classes">Final Classes</a></h3></div></div></div><p>
Final classes cannot be derived, otherwise the compiler will generated an
error. This library allows to declare a class final by specifying <code class="computeroutput"><span class="identifier">final</span></code> within the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>
macro after the class name, after template specialization types but before
base classes if present (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section).
</p><p>
For example (see also <a class="ulink" href="../../example/virtual_specifiers/final_class.hpp" target="_top"><code class="literal">final_class.hpp</code></a> and
<a class="ulink" href="../../example/virtual_specifiers/final_class.cpp" target="_top"><code class="literal">final_class.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="identifier">final</span> <span class="comment">// A final class.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">};</span>
</pre><p>
</p><p>
If a derived class declared using <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>
attempts to inherit from a final base class, the compiler will generate a
compile-time error (this is true only if both the base and derived classes
are declared using this library macro <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>).
For example, consider the following derived class (see also <a class="ulink" href="../../example/virtual_specifiers/final_class_error.cpp" target="_top"><code class="literal">final_class_error.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">y</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">x</span> <span class="special">)</span> <span class="comment">// Correctly errors because `x` is final.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">};</span>
</pre><p>
</p><p>
This will generate a compile-time error similar to the following because
<code class="computeroutput"><span class="identifier">x</span></code> is final (note that the
number of the base class that violates the <code class="computeroutput"><span class="identifier">final</span></code>
specifier is reported so it is clear which base class is causing the error
also in case of multiple-inheritance):
</p><pre class="programlisting">final_class_error.cpp:8 ... ERROR_cannot_extend_final_base_class_number_1 ...
</pre><p>
Final class checks are performed at compile-time even when contracts are
disabled (using <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>,
etc).
</p></div><div class="section" title="Final Member Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.virtual_specifiers.final_member_functions"></a><a class="link" href="#contract__.virtual_specifiers.final_member_functions" title="Final Member Functions">Final
Member Functions</a></h3></div></div></div><p>
Final member functions cannot be overridden by derived classes, otherwise
the compiler will generate an error. This library allows to declare a member
function final by specifying <code class="computeroutput"><span class="identifier">final</span></code>
within the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
macro, after the cv-qualifier but before exception specifications if present
(see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section).
</p><p>
For example (see also <a class="ulink" href="../../example/virtual_specifiers/final_member.hpp" target="_top"><code class="literal">final_member.hpp</code></a> and
<a class="ulink" href="../../example/virtual_specifiers/final_member.cpp" target="_top"><code class="literal">final_member.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">x</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">y</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">final</span> <span class="comment">// Final member function.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
</pre><p>
</p><p>
If a member function of a derived class is declared using <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
and attempts to override a final member function from one of the base classes,
the compiler will generate a compile-time error (this is true only if both
the overriding and overridden functions are declared using this library macro
<code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>). For example,
consider the following derived class (see also <a class="ulink" href="../../example/virtual_specifiers/final_member_error.cpp" target="_top"><code class="literal">final_member_error.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">z</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">y</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Correctly errors because `y::f` is final.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
</pre><p>
</p><p>
This will generate a compile-time error similar to the following because
<code class="computeroutput"><span class="identifier">y</span><span class="special">::</span><span class="identifier">f</span></code> is final (note that the number of the
base class that violates the <code class="computeroutput"><span class="identifier">final</span></code>
specifier is reported so it is clear which overridden member function is
causing the error also in case of multiple-inheritance):
</p><pre class="programlisting">final_member_error.cpp:13 ... ERROR_cannot_override_final_function_from_base_class_number_1 ...
</pre><p>
In order to correctly handle overloaded functions, the overriding function
and the final function must have the same name, parameter types, and cv-qualifier
to generate this error.
</p><p>
Final member function checks are performed at compile-time but only when
class invariants are enabled (<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>
is left not defined).
</p></div><div class="section" title="Overriding Member Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.virtual_specifiers.overriding_member_functions"></a><a class="link" href="#contract__.virtual_specifiers.overriding_member_functions" title="Overriding Member Functions">Overriding
Member Functions</a></h3></div></div></div><p>
Overriding member functions must override a virtual member function from
one or more of the base classes, otherwise the compiler will generate an
error. This library allows to declare an overriding member function by specifying
<code class="computeroutput"><span class="identifier">override</span></code> within the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macro, after the cv-qualifier
but before the <code class="computeroutput"><span class="identifier">final</span></code> specifier
if present (<code class="computeroutput"><span class="identifier">override</span></code> and
<code class="computeroutput"><span class="identifier">final</span></code> can be used together,
see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section).
</p><p>
For example (see also <a class="ulink" href="../../example/virtual_specifiers/override_member.hpp" target="_top"><code class="literal">override_member.hpp</code></a> and
<a class="ulink" href="../../example/virtual_specifiers/override_member.cpp" target="_top"><code class="literal">override_member.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">x</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Virtual so it can be overridden.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">g</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Not virtual so it cannot be overridden.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">y</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span> <span class="comment">// OK, overriding virtual `x::f`.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
</pre><p>
</p><p>
If a member function of a derived class is declared using <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
and attempts to override an non-virtual or non-existing member function from
one of the base classes, the compiler will generate a compile-time error
(this is true only if both the overriding and overridden functions are declared
using this library macro <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>).
For example, consider the following derived class (see also <a class="ulink" href="../../example/virtual_specifiers/override_member_error.cpp" target="_top"><code class="literal">override_member_error.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">z</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">g</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span> <span class="comment">// Correctly errors, cannot override.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
</pre><p>
</p><p>
This will generate a compile-time error similar to the following because
<code class="computeroutput"><span class="identifier">x</span><span class="special">::</span><span class="identifier">g</span></code> is not virtual:
</p><pre class="programlisting">override_member_error.cpp:12 ... ERROR_no_base_class_declares_matching_virtual_function_to_override_at_line_12 ...
</pre><p>
In order to correctly handle overloaded functions, the overriding function
and the overridden virtual function must have the same name, parameter types,
and cv-qualifier to <span class="emphasis"><em>not</em></span> generate this error.
</p><p>
Overriding member function checks are performed at compile-time but only
if at least one between preconditions, postconditions, and class invariants
is enabled (<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>
are not all defined at the same time).
</p></div><div class="section" title="New Member Functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.virtual_specifiers.new_member_functions"></a><a class="link" href="#contract__.virtual_specifiers.new_member_functions" title="New Member Functions">New
Member Functions</a></h3></div></div></div><p>
New member functions shall not override member functions from any of the
base classes, otherwise the compiler will generate an error. This library
allows to declare a new member function by specifying <code class="computeroutput"><span class="keyword">new</span></code>
within the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
macro, after the cv-qualifier but before the <code class="computeroutput"><span class="identifier">final</span></code>
specifier if present (<code class="computeroutput"><span class="keyword">new</span></code> and
<code class="computeroutput"><span class="identifier">final</span></code> can be used together,
see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section).
</p><p>
For example (see also <a class="ulink" href="../../example/virtual_specifiers/new_member.hpp" target="_top"><code class="literal">new_member.hpp</code></a> and
<a class="ulink" href="../../example/virtual_specifiers/new_member.cpp" target="_top"><code class="literal">new_member.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">x</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">new</span> <span class="comment">// OK, no base so no `f` override.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">y</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">g</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">new</span> <span class="comment">// OK, there is no `x::g`.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
</pre><p>
</p><p>
If a new member function of a derived class is declared using <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> but it overrides an
existing member function from one of the base classes, the compiler will
generate a compile-time error (this is true only if both the overriding and
overridden functions are declared using this library macro <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>).
For example, consider the following derived class (see also <a class="ulink" href="../../example/virtual_specifiers/new_member_error.cpp" target="_top"><code class="literal">new_member_error.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">z</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">y</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">g</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">new</span> <span class="comment">// Correctly errors because `y::g`.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
</pre><p>
</p><p>
This will generate a compile-time error similar to the following because
<code class="computeroutput"><span class="identifier">f</span></code> was already declared in
<code class="computeroutput"><span class="identifier">x</span></code> (note that the number of
the base class that violates the <code class="computeroutput"><span class="keyword">new</span></code>
specifier is reported so it is clear which overridden member function is
causing the error also in case of multiple-inheritance):
</p><pre class="programlisting">new_member_error.cpp:12 ... ERROR_matching_virtual_function_already_declared_by_base_class_number_1 ...
</pre><p>
In order to correctly handle overloaded functions, the new function and the
overridden function must have the same name, parameter types, and cv-qualifier
to generate this error.
</p><p>
New member function checks are performed at compile-time but only if at least
one between preconditions, postconditions, and class invariants is enabled
(<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a></code>
are not all defined at the same time).
</p></div></div><div class="section" title="Concepts"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.concepts"></a><a class="link" href="#contract__.concepts" title="Concepts">Concepts</a></h2></div></div></div><p>
This section explains how to use this library to check concepts. Concepts are
part of the program specifications because they enforce requirements on generic
types at compile-time and therefore they are within the scope of this library.
</p><p>
Concepts were proposed for addition to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
but they were unfortunately never adopted (see <a class="link" href="#N2081_anchor">[N2081]</a>).
The concepts that are checked using this library need to be defined using the
<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
library. This library does not add any extra functionality with respect to
the concept checking features already provided by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
but it allows to specify both concepts and contracts together within a unified
syntax.
</p><div class="section" title="Class Templates"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.concepts.class_templates"></a><a class="link" href="#contract__.concepts.class_templates" title="Class Templates">Class Templates</a></h3></div></div></div><p>
It is possible to list the concepts to check for class templates using <code class="computeroutput"><span class="identifier">requires</span></code> within the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code>
macro, after the template parameter declarations (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section):
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">(</span> <span class="emphasis"><em>template-parameter1</em></span><span class="special">,</span> <span class="emphasis"><em>template-parameter2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <span class="emphasis"><em>concept1</em></span><span class="special">,</span> <span class="emphasis"><em>concept2</em></span><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
</pre><p>
The following example requires that the generic type <code class="computeroutput"><span class="identifier">T</span></code>
specified for the class template <code class="computeroutput"><span class="identifier">vector</span></code>
is always <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/CopyConstructible.html" target="_top"><code class="literal">CopyConstructible</code></a>
and it uses the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">CopyConstructible</span></code> concept defined by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
(see also <a class="ulink" href="../../example/concepts/class_member_concept_vector.hpp" target="_top"><code class="literal">class_member_concept_vector.hpp</code></a>,
<a class="ulink" href="../../example/concepts/class_member_concept_vector_error.cpp" target="_top"><code class="literal">class_member_concept_vector_error.cpp</code></a>,
and <a class="ulink" href="../../example/concepts/class_member_concept_vector.cpp" target="_top"><code class="literal">class_member_concept_vector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span> <span class="comment">// Boost.ConceptCheck predefined concepts.</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">CopyConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span> <span class="comment">// Check concepts.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">()</span>
<span class="special">)</span>
<span class="comment">// ...</span>
</pre><p>
</p><p>
If the class template <code class="computeroutput"><span class="identifier">vector</span></code>
is instantiated on a type <code class="computeroutput"><span class="identifier">T</span></code>
that is not <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/CopyConstructible.html" target="_top"><code class="literal">CopyConstructible</code></a>,
the compiler will generate an error (with the usual format of <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
errors).
</p></div><div class="section" title="Function Templates"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.concepts.function_templates"></a><a class="link" href="#contract__.concepts.function_templates" title="Function Templates">Function Templates</a></h3></div></div></div><p>
It is possible to list concepts to check for function templates using <code class="computeroutput"><span class="identifier">requires</span></code> within the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
macro, after the template parameter declarations (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section).
</p><p>
For example, for a constructor function template (see also <a class="ulink" href="../../example/concepts/class_member_concept_vector.hpp" target="_top"><code class="literal">class_member_concept_vector.hpp</code></a>,
<a class="ulink" href="../../example/concepts/class_member_concept_vector_constructor_error.cpp" target="_top"><code class="literal">class_member_concept_vector_constructor_error.cpp</code></a>,
and <a class="ulink" href="../../example/concepts/class_member_concept_vector.cpp" target="_top"><code class="literal">class_member_concept_vector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span> <span class="special">)</span> <span class="comment">// Check concepts.</span>
<span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
</pre><p>
</p><p>
And, for a member function template (see also <a class="ulink" href="../../example/concepts/class_member_concept_vector.hpp" target="_top"><code class="literal">class_member_concept_vector.hpp</code></a>,
<a class="ulink" href="../../example/concepts/class_member_concept_vector_member_error.cpp" target="_top"><code class="literal">class_member_concept_vector_member_error.cpp</code></a>,
and <a class="ulink" href="../../example/concepts/class_member_concept_vector.cpp" target="_top"><code class="literal">class_member_concept_vector.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span> <span class="special">)</span> <span class="comment">// Check concepts.</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">insert</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">where</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_increased_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_increased_size</span><span class="special">,</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">where</span><span class="special">,</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
</p><p>
If the <code class="computeroutput"><span class="identifier">vector</span></code> constructor
template or the <code class="computeroutput"><span class="identifier">vector</span><span class="special">::</span><span class="identifier">insert</span></code> member function template are instantiated
on a type <code class="computeroutput"><span class="identifier">Iterator</span></code> that is
not an <a class="ulink" href="http://www.sgi.com/tech/stl/InputIterator.html" target="_top"><code class="literal">InputIterator</code></a>,
the compiler will generate an error (with the usual format of <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
errors).
</p><p>
So far we have used concepts that are predefined by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
but it is also possible to check user-defined concepts as long as they are
defined using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>.
For example, consider the following user-defined <code class="computeroutput"><span class="identifier">Addable</span></code>
concept (see also <a class="ulink" href="../../example/concepts/free_concept_operator_preinc.hpp" target="_top"><code class="literal">free_concept_operator_preinc.hpp</code></a>,
<a class="ulink" href="../../example/concepts/free_concept_operator_preinc_error.cpp" target="_top"><code class="literal">free_concept_operator_preinc_error.cpp</code></a>,
and <a class="ulink" href="../../example/concepts/free_concept_operator_preinc.cpp" target="_top"><code class="literal">free_concept_operator_preinc.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">Addable</span> <span class="comment">// New concept defined and implemented using Boost.ConceptCheck.</span>
<span class="special">{</span>
<span class="identifier">BOOST_CONCEPT_USAGE</span><span class="special">(</span><span class="identifier">Addable</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">return_type</span><span class="special">(</span><span class="identifier">x</span> <span class="special">+</span> <span class="identifier">y</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="keyword">void</span> <span class="identifier">return_type</span> <span class="special">(</span> <span class="identifier">T</span> <span class="special">)</span> <span class="special">{}</span>
<span class="keyword">static</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">;</span>
<span class="keyword">static</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">Assignable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="comment">// Check both predefined and</span>
<span class="identifier">Addable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="comment">// newly defined concepts.</span>
<span class="special">)</span>
<span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(++)(</span><span class="identifier">preinc</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span><span class="special">,</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">+</span> <span class="identifier">T</span><span class="special">(</span><span class="number">1</span><span class="special">),</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">value</span> <span class="special">+</span> <span class="identifier">T</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
</p><p>
If this templated operator <code class="computeroutput"><span class="special">++</span></code>
is instantiated on a type <code class="computeroutput"><span class="identifier">T</span></code>
that is not <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/Assignable.html" target="_top"><code class="literal">Assignable</code></a>
or not <code class="computeroutput"><span class="identifier">Addable</span></code>, the compiler
will generate an error (with the usual format of <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
error).
</p><p>
Note that concepts can also be specified for free function templates, for
free operator templates, and for member operator templates (as illustrated
in some of the above examples).
</p></div><div class="section" title="Concept Definitions (Not Implemented)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.concepts.concept_definitions__not_implemented_"></a><a class="link" href="#contract__.concepts.concept_definitions__not_implemented_" title="Concept Definitions (Not Implemented)">Concept
Definitions (Not Implemented)</a></h3></div></div></div><p>
Using the preprocessor parsing techniques introduced by the library, it should
be possible to implement the following syntax to define <a class="ulink" href="http://en.wikipedia.org/wiki/Concepts_(C%2B%2B)" target="_top">concepts</a>.
Note how this syntax resembles the syntax proposed by <a class="link" href="#N2081_anchor">[N2081]</a>
for adding concepts to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
(<a class="link" href="#N2081_anchor">[N2081]</a> and concepts were unfortunately
not adopted by the standard committee).
</p><pre class="programlisting"><span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// A concept definition.</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">LessThanComparable</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">(&lt;)(</span><span class="identifier">less</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span> <span class="special">,</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Concepts with multiple parameters.</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">Convertible</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">operator</span><span class="special">(</span><span class="identifier">U</span><span class="special">)(</span><span class="identifier">U_type</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Concept composition.</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">InputIterator</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Value</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">requires</span> <span class="identifier">Regular</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;,</span>
<span class="special">(</span><span class="identifier">Value</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">deref</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">Iterator</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">Iterator</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(++)(</span><span class="identifier">preinc</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">Iterator</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(++)(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">Iterator</span><span class="special">&amp;,</span> <span class="keyword">int</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Derived concepts.</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">ForwardIterator</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Value</span> <span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">,</span> <span class="identifier">Value</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span>
<span class="comment">// Other requirements here...</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Typenames within concepts.</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">InputIterator</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">reference</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">pointer</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">difference_type</span><span class="special">,</span>
<span class="identifier">requires</span> <span class="identifier">Regular</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;,</span>
<span class="identifier">requires</span> <span class="special">(</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">reference</span><span class="special">,</span> <span class="identifier">value_type</span><span class="special">&gt;),</span>
<span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">deref</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Iterator</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">Iterator</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(++)(</span><span class="identifier">preinc</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">Iterator</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(++)(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">Iterator</span><span class="special">&amp;,</span> <span class="keyword">int</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Concept maps.</span>
<span class="identifier">concept_map</span> <span class="special">(</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;)</span>
<span class="special">(</span>
<span class="keyword">typedef</span> <span class="keyword">char</span> <span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="keyword">char</span><span class="special">&amp;)</span> <span class="identifier">reference</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="keyword">char</span><span class="special">*)</span> <span class="identifier">pointer</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Concept maps can be templated.</span>
<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="identifier">concept_map</span> <span class="special">(</span><span class="identifier">InputIterator</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">*</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">reference</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="identifier">T</span><span class="special">*)</span> <span class="identifier">pointer</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Concept maps as mini-types.</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">Stack</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">X</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">push</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;,</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">pop</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">value_type</span><span class="special">)</span> <span class="special">(</span><span class="identifier">top</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="keyword">bool</span> <span class="special">(</span><span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Concept maps as mini-types (specializations).</span>
<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="identifier">concept_map</span> <span class="special">(</span><span class="identifier">Stack</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">push</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;)</span> <span class="identifier">v</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</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="special">(</span><span class="identifier">pop</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;)</span> <span class="identifier">v</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">pop_back</span><span class="special">();</span>
<span class="special">),</span>
<span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">top</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">v</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">return</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span>
<span class="special">),</span>
<span class="keyword">bool</span> <span class="special">(</span><span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">v</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">return</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">emtpy</span><span class="special">();</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span> <span class="comment">// Axioms.</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">Semigroup</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Op</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="identifier">CopyConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span>
<span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(())(</span><span class="identifier">call</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">Op</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">),</span>
<span class="identifier">axiom</span> <span class="special">(</span><span class="identifier">Associativity</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Op</span><span class="special">)</span> <span class="identifier">op</span><span class="special">,</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="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="identifier">T</span><span class="special">)</span> <span class="identifier">z</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">op</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">op</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">))</span> <span class="special">==</span> <span class="identifier">op</span><span class="special">(</span><span class="identifier">op</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">),</span> <span class="identifier">z</span><span class="special">);</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
</pre><p>
Note that:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Parenthesis around function parameter types can be always allowed but
they should be required only when the parameter name is also specified.
</li><li class="listitem">
The function bodies need to be specified within the macros and that will
make compiler errors very hard to use (because the errors will all refer
to the same line number, the line number on which the <code class="computeroutput"><span class="identifier">CONTRACT_CONCEPT</span></code>
macro expanded). However, concept definitions, including possible function
bodies, might be simple enough for this not to be a major issue at least
in the most common cases (the authors do not have enough experience with
programming concept definitions to truly assess this).
</li></ol></div><p>
The authors <span class="emphasis"><em>think</em></span> this syntax can be implemented and
parsed using the preprocessor however the authors have not tried to implement
this yet. If this syntax can indeed be implemented, it should then be investigated
if the actual concept definitions can be programmed from the parsed concept
traits using C++ (this seems possible at least for <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
based on some work done for the <a class="ulink" href="http://zao.se/~zao/boostcon/11/slides/Boost.Generic.pdf" target="_top">Generic</a>
library).
</p><p>
The authors recognize that implementing concept definitions would be a nice
addition to this library (again, concepts are parts of the program specifications,
they are contracts on the type system that are checked at compile-time, so
both concept checking and concept definition are within the scope of this
library). However, at the moment there are no concrete plans for extending
this library with the concept definitions (see also <a class="ulink" href="https://sourceforge.net/apps/trac/contractpp/ticket/49" target="_top">Ticket
49</a>).
</p><p>
The following is a side-by-side comparison of this possible concept definition
syntax with the syntax proposed by <a class="link" href="#N2081_anchor">[N2081]</a>:
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
Possible Extension of This Library (not implemented)
</p>
</th><th>
<p>
[N2081] Proposal (not part of C++)
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">ArithmeticLike</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span>
<span class="identifier">Regular</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">LessThanComparable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">HasUnaryPlus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">HasNegate</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="special">(</span><span class="identifier">HasPlus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;),</span>
<span class="special">(</span><span class="identifier">HasMinus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span>
<span class="comment">// ...</span>
<span class="special">)</span>
<span class="special">(</span>
<span class="keyword">explicit</span> <span class="identifier">constructor_body</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">intmax_t</span><span class="special">),</span>
<span class="keyword">explicit</span> <span class="identifier">constructor_body</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">uintmax_t</span> <span class="special">),</span>
<span class="keyword">explicit</span> <span class="identifier">constructor_body</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="special">),</span>
<span class="identifier">requires</span> <span class="special">(</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">HasUnaryPlus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">result_type</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span>
<span class="comment">// ...</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">HasFind</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">key_type</span><span class="special">,</span> <span class="identifier">as</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">key_type</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">mapped_type</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">key_type</span><span class="special">,</span> <span class="identifier">mapped_type</span><span class="special">&gt;)</span> <span class="special">(</span><span class="identifier">find</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">HasDereference</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">result_type</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">result_type</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">deref</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">result_type</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">deref</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">IdentityOf</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">type</span><span class="special">,</span> <span class="identifier">as</span> <span class="identifier">T</span><span class="special">,</span>
<span class="identifier">requires</span> <span class="special">(</span><span class="identifier">SameType</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">MemberFunctionRequirements</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">constructor_body</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">b</span> <span class="special">),</span>
<span class="identifier">destructor_body</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="special">~</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">),</span>
<span class="keyword">void</span> <span class="identifier">member_body</span><span class="special">(</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">f</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">HasEqualTo</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">(==)(</span><span class="identifier">equal</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">ExplicitlyConvertible</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">explicit</span> <span class="keyword">operator</span><span class="special">(</span><span class="identifier">U</span><span class="special">)(</span><span class="identifier">U_type</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">Convertible</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="special">(</span><span class="identifier">ExplicitlyConvetible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;)</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">operator</span><span class="special">(</span><span class="identifier">U</span><span class="special">)(</span><span class="identifier">U_type</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">True</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">bool</span> <span class="identifier">Value</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">void</span> <span class="comment">// Empty concept definition.</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="identifier">concept_map</span> <span class="special">(</span><span class="identifier">True</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">true</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">void</span> <span class="comment">// Empty concept definition.</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">IsEven</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">intmax_t</span> <span class="identifier">Value</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">requires</span> <span class="identifier">True</span><span class="special">&lt;</span><span class="identifier">V</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">0</span><span class="special">&gt;</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="special">(</span><span class="identifier">CopyConstructible</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="identifier">MoveConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="special">(</span><span class="identifier">Constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;&gt;)</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">axiom</span> <span class="special">(</span><span class="identifier">CopyPreservation</span><span class="special">)</span> <span class="special">(</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="special">(</span>
<span class="identifier">T</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">X</span> <span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="identifier">Semiregular</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typename</span><span class="special">(</span><span class="identifier">MoveConstructible</span><span class="special">)</span> <span class="identifier">reference</span><span class="special">,</span> <span class="identifier">as</span> <span class="keyword">typename</span> <span class="identifier">X</span><span class="special">::</span><span class="identifier">reference</span><span class="special">,</span>
<span class="keyword">typename</span><span class="special">(</span><span class="identifier">MoveConstructible</span><span class="special">)</span> <span class="identifier">postinc_result</span><span class="special">,</span>
<span class="identifier">requires</span> <span class="identifier">HasDereference</span><span class="special">&lt;</span><span class="identifier">postinc_result</span><span class="special">&gt;,</span>
<span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">deref</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(*)(</span><span class="identifier">deref</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">X</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(++)(</span><span class="identifier">preinc</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">postinc_result</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(++)(</span><span class="identifier">postinc</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;,</span> <span class="keyword">int</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="identifier">concept</span> <span class="special">(</span><span class="identifier">RandomAccessIterator</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">X</span> <span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="identifier">BidirectionalIterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;,</span> <span class="identifier">LessThanComparable</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typename</span><span class="special">(</span><span class="identifier">MoveConstructible</span><span class="special">)</span> <span class="identifier">reference</span><span class="special">,</span>
<span class="identifier">requires</span> <span class="special">(</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">reference</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;&gt;),</span>
<span class="special">(</span><span class="identifier">X</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(+=)(</span><span class="identifier">inc</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;,</span> <span class="identifier">difference_type</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">X</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(+)(</span><span class="identifier">add</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">x</span><span class="special">,</span> <span class="special">(</span><span class="identifier">difference_type</span><span class="special">)</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">X</span> <span class="identifier">y</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">y</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">),</span>
<span class="special">(</span><span class="identifier">X</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(+)(</span><span class="identifier">add</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">difference_type</span><span class="special">)</span> <span class="identifier">n</span><span class="special">,</span> <span class="special">(</span><span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">X</span> <span class="identifier">y</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">y</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">),</span>
<span class="special">(</span><span class="identifier">X</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(-=)(</span><span class="identifier">dec</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;,</span> <span class="identifier">difference_type</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">X</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(-)(</span><span class="identifier">sub</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">x</span><span class="special">,</span> <span class="special">(</span><span class="identifier">difference_type</span><span class="special">)</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="special">(</span>
<span class="identifier">X</span> <span class="identifier">y</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">y</span> <span class="special">-=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">),</span>
<span class="special">(</span><span class="identifier">difference_type</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">(-)(</span><span class="identifier">sub</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">),</span>
<span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">difference_type</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONCEPT</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span><span class="special">(</span><span class="identifier">ObjectType</span><span class="special">)</span> <span class="identifier">T</span> <span class="special">)</span>
<span class="identifier">concept_map</span> <span class="special">(</span><span class="identifier">RandomAccessIterator</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">*</span> <span class="special">)</span>
<span class="special">(</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">reference</span><span class="special">,</span>
<span class="keyword">typedef</span> <span class="special">(</span><span class="identifier">T</span><span class="special">*)</span> <span class="identifier">pointer</span>
<span class="special">)</span>
<span class="special">)</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="comment">// Extra spaces, newlines, etc used to align text with this library code.</span>
<span class="identifier">concept</span> <span class="identifier">ArithmeticLike</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="special">:</span>
<span class="identifier">Regular</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">LessThanComparable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">HasUnaryPlus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">HasNegate</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">HasPlus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">HasMinus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="comment">// ...</span>
<span class="special">{</span>
<span class="keyword">explicit</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span> <span class="identifier">intmax_t</span> <span class="special">)</span> <span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span> <span class="identifier">uintmax_t</span> <span class="special">)</span> <span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span> <span class="keyword">long</span> <span class="keyword">double</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">requires</span> <span class="identifier">Convertible</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">HasUnaryPlus</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">result_type</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">;</span>
<span class="comment">// ...</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">HasFind</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">typename</span> <span class="identifier">key_type</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">key_type</span> <span class="special">;</span>
<span class="keyword">typename</span> <span class="identifier">mapped_type</span> <span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">key_type</span><span class="special">,</span> <span class="identifier">mapped_type</span><span class="special">&gt;</span> <span class="identifier">find</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">key_type</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">HasDereference</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">typename</span> <span class="identifier">result_type</span> <span class="special">;</span>
<span class="identifier">result_type</span> <span class="keyword">operator</span><span class="special">*</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">result_type</span> <span class="keyword">operator</span><span class="special">*</span> <span class="special">(</span> <span class="identifier">T</span><span class="special">&amp;&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">IdentityOf</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">typename</span> <span class="identifier">type</span> <span class="special">=</span> <span class="identifier">T</span> <span class="special">;</span>
<span class="identifier">requires</span> <span class="identifier">SameType</span><span class="special">&lt;</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">MemberFunctionRequirements</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">float</span> <span class="identifier">b</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">T</span><span class="special">::~</span><span class="identifier">T</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">T</span><span class="special">::</span><span class="identifier">f</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">HasEqualTo</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">U</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">ExplicitlyConvertible</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="identifier">U</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">Convertible</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">U</span> <span class="special">&gt;</span>
<span class="special">:</span> <span class="identifier">ExplicitlyConvetible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">U</span><span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">operator</span> <span class="identifier">U</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="special">}</span>
<span class="identifier">concept</span> <span class="identifier">True</span> <span class="special">&lt;</span> <span class="keyword">bool</span> <span class="identifier">Value</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="comment">// No operation.</span>
<span class="special">}</span>
<span class="identifier">concept_map</span> <span class="identifier">True</span> <span class="special">&lt;</span> <span class="keyword">true</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="comment">// No operation.</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">IsEven</span> <span class="special">&lt;</span> <span class="identifier">intmax_t</span> <span class="identifier">Value</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="identifier">requires</span> <span class="identifier">True</span><span class="special">&lt;</span><span class="identifier">V</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">0</span><span class="special">&gt;</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">auto</span> <span class="identifier">concept</span> <span class="identifier">CopyConstructible</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="special">:</span> <span class="identifier">MoveConstructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">Constructible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;&gt;</span>
<span class="special">{</span>
<span class="identifier">axiom</span> <span class="identifier">CopyPreservation</span> <span class="special">(</span> <span class="identifier">T</span> <span class="identifier">x</span> <span class="special">)</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="special">==</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="identifier">concept</span> <span class="identifier">Iterator</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">X</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">Semiregular</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span>
<span class="special">{</span>
<span class="identifier">MoveConstructible</span> <span class="identifier">reference</span> <span class="special">=</span> <span class="keyword">typename</span> <span class="identifier">X</span><span class="special">::</span><span class="identifier">reference</span> <span class="special">;</span>
<span class="identifier">MoveConstructible</span> <span class="identifier">postinc_result</span> <span class="special">;</span>
<span class="identifier">requires</span> <span class="identifier">HasDereference</span><span class="special">&lt;</span><span class="identifier">postinc_result</span><span class="special">&gt;</span> <span class="special">;</span>
<span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">*</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">X</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">++</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">postinc_result</span> <span class="keyword">operator</span><span class="special">++</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;,</span> <span class="keyword">int</span> <span class="special">)</span> <span class="special">;</span>
<span class="special">}</span>
<span class="identifier">concept</span> <span class="identifier">RandomAccessIterator</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">X</span> <span class="special">&gt;</span>
<span class="special">:</span> <span class="identifier">BidirectionalIterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;,</span> <span class="identifier">LessThanComparable</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span>
<span class="special">{</span>
<span class="identifier">MoveConstructible</span> <span class="identifier">reference</span> <span class="special">;</span>
<span class="identifier">requires</span> <span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">reference</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;&gt;</span> <span class="special">;</span>
<span class="identifier">X</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">+=</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;,</span> <span class="identifier">difference_type</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">X</span> <span class="keyword">operator</span><span class="special">+</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">difference_type</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">X</span> <span class="identifier">y</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">y</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">X</span> <span class="keyword">operator</span><span class="special">+</span> <span class="special">(</span> <span class="identifier">difference_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">X</span> <span class="identifier">y</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">x</span> <span class="special">+=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">X</span> <span class="keyword">operator</span><span class="special">-=</span> <span class="special">(</span> <span class="identifier">X</span><span class="special">&amp;,</span> <span class="identifier">difference_type</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">X</span> <span class="keyword">operator</span><span class="special">-</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">difference_type</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">X</span> <span class="identifier">y</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">y</span> <span class="special">-=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">difference_type</span> <span class="keyword">operator</span><span class="special">-</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">;</span>
<span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">[]</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;,</span> <span class="identifier">difference_type</span> <span class="special">)</span> <span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="identifier">ObjectType</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">concept_map</span> <span class="identifier">RandomAccessIterator</span> <span class="special">&lt;</span> <span class="identifier">T</span><span class="special">*</span> <span class="special">&gt;</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">value_type</span> <span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span> <span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">reference</span> <span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">pointer</span> <span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p>
</td></tr></tbody></table></div><p>
Note that:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Extra wrapping parenthesis are used when expressions contain unwrapped
commas <code class="computeroutput"><span class="special">,</span></code> or leading symbols.
</li><li class="listitem">
The specifiers <code class="computeroutput"><span class="identifier">constructor_body</span></code>,
<code class="computeroutput"><span class="identifier">destructor_body</span></code>, and
<code class="computeroutput"><span class="identifier">member_body</span></code> follow the
same syntax as the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_BODY" title="Macro CONTRACT_CONSTRUCTOR_BODY">CONTRACT_CONSTRUCTOR_BODY</a></code>,
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_BODY" title="Macro CONTRACT_DESTRUCTOR_BODY">CONTRACT_DESTRUCTOR_BODY</a></code>,
and <code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code>
macros and they serve a purpose similar to these macros in naming the
constructor, destructor, and member function bodies outside class declarations.
</li></ol></div><p>
If concept definitions were added to this library, concepts would still be
checked using the <code class="computeroutput"><span class="identifier">requires</span></code>
specifier in class and function declarations as we have seen so far (it might
even be possible for concepts defines using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
to be still specified using some type tagging of this library concept types
to internally distinguish between <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>
concepts and concepts define using this library). Furthermore, this library
could provide all the standard concepts defined in <a class="link" href="#N2914_anchor">[N2914]</a>
in an header file <code class="literal">contract/std/concept.hpp</code>.
</p></div></div><div class="section" title="Named Parameters"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.named_parameters"></a><a class="link" href="#contract__.named_parameters" title="Named Parameters">Named Parameters</a></h2></div></div></div><p>
This section explains how to use this library to program named parameters and
deduced named parameters which are used instead of C++ usual positional parameters
to specify arguments to function calls. Parameter names are part of the program
specifications and therefore named parameters are within the scope of this
library.
</p><p>
This library internally uses <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
to implement named parameters. This library only offers an easier syntax for
constructor and class template named parameters with respect the functionality
already provided by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>,
but this library allows to specify named parameters, concepts, and contracts
all together within a unified syntax.
</p><div class="section" title="Overview"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.overview"></a><a class="link" href="#contract__.named_parameters.overview" title="Overview">Overview</a></h3></div></div></div><p>
In C++, parameters are identified with respect to their declaration position
within the parameter list: The first call <span class="emphasis"><em>argument</em></span> (i.e.,
the specific value assigned to the formal parameter at the call site) maps
to the first declared parameter, the second call argument maps to the second
declared parameter, etc. For example:
</p><pre class="programlisting"><span class="identifier">window</span><span class="special">*</span> <span class="identifier">make_window</span><span class="special">(</span>
<span class="keyword">char</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">name</span><span class="special">,</span>
<span class="identifier">size_t</span> <span class="identifier">width</span> <span class="special">=</span> <span class="number">10</span><span class="special">,</span>
<span class="keyword">bool</span> <span class="identifier">moveable</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">,</span>
<span class="keyword">bool</span> <span class="identifier">visible</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="special">)</span>
<span class="special">;</span>
</pre><p>
This protocol is sufficient when there is at most one parameter with a useful
default value but when there are even a few useful default parameters the
positional interface becomes difficult to use at the calling site. For example,
in the following call we need to repeat the default parameter value <code class="computeroutput"><span class="number">10</span></code>:
</p><pre class="programlisting"><span class="keyword">bool</span> <span class="keyword">const</span> <span class="identifier">unmoveable</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
<span class="identifier">make_window</span><span class="special">(</span><span class="string">"warning"</span><span class="special">,</span> <span class="number">10</span><span class="special">,</span> <span class="identifier">unmoveable</span><span class="special">);</span> <span class="comment">// Positional (usual).</span>
</pre><p>
Furthermore, it would be easier to understand the meaning of the arguments
at the calling site if the parameters could be referred by their names. For
example, in order to understand if the following window is moveable and invisible,
or unmoveable and visible, programmers at the calling site need to remember
the order of the parameter declarations:
</p><pre class="programlisting"><span class="identifier">make_window</span><span class="special">(</span><span class="string">"note"</span><span class="special">,</span> <span class="number">10</span><span class="special">,</span> <span class="keyword">true</span><span class="special">,</span> <span class="keyword">false</span><span class="special">);</span> <span class="comment">// Positional (usual).</span>
</pre><p>
These issues would be solved if the parameter names could be referred at
the calling site and that is what <a class="ulink" href="http://en.wikipedia.org/wiki/Named_parameter" target="_top"><span class="emphasis"><em>named
parameters</em></span></a> allow to do:
</p><pre class="programlisting"><span class="identifier">make_window</span><span class="special">(</span><span class="string">"warning"</span><span class="special">,</span> <span class="identifier">moveable</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">);</span> <span class="comment">// Named.</span>
<span class="identifier">make_widnow</span><span class="special">(</span><span class="string">"note"</span><span class="special">,</span> <span class="identifier">visible</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">);</span>
</pre><p>
Named parameters were proposed for addition to early versions of C++ but
the proposal was never accepted (see <span class="quote">&#8220;<span class="quote">keyword arguments</span>&#8221;</span> in
<a class="link" href="#Stroustrup94_anchor">[Stroustrup94]</a>). Other programming
languages support named parameters (<a class="ulink" href="http://en.wikipedia.org/wiki/Ada_(programming_language)" target="_top">Ada</a>,
<a class="ulink" href="http://www.python.org/" target="_top">Python</a>, etc).
</p><p>
Furthermore, <span class="emphasis"><em>deduced named parameters</em></span> are named parameters
that can be passed in any position and without supplying their names. These
are useful when functions have parameters that can be uniquely identified
(or <span class="emphasis"><em>deduced</em></span>) based on the argument types of the function
call. For example, the <code class="computeroutput"><span class="identifier">name</span></code>
parameter is such a parameter, it can be deduced because no other argument,
if valid, can be reasonably converted into a <code class="computeroutput"><span class="keyword">char</span>
<span class="keyword">const</span><span class="special">*</span></code>.
Therefore, with a deduced parameter interface, we could pass the window name
in any position without causing any ambiguity (with an appropriately designed
deduced parameter interface, the caller might not even have to remember the
actual parameter names):
</p><pre class="programlisting"><span class="identifier">make_window</span><span class="special">(</span><span class="identifier">moveable</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">,</span> <span class="string">"warning"</span><span class="special">);</span> <span class="comment">// Deduced.</span>
<span class="identifier">make_window</span><span class="special">(</span><span class="string">"note"</span><span class="special">,</span> <span class="identifier">visible</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">);</span>
</pre><p>
The same reasoning applies to named template parameters and deduced named
template parameters:
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">ValueType</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">Shared</span> <span class="special">=</span> <span class="keyword">true</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">smart_ptr</span> <span class="special">;</span>
<span class="identifier">smart_ptr</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">false</span><span class="special">&gt;</span> <span class="identifier">p1</span><span class="special">;</span> <span class="comment">// Positional (usual).</span>
<span class="identifier">smart_ptr</span><span class="special">&lt;</span><span class="keyword">false</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">p2</span><span class="special">;</span> <span class="comment">// Deduced.</span>
<span class="identifier">smart_ptr</span><span class="special">&lt;</span><span class="identifier">Shared</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">,</span> <span class="identifier">ValueType</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">p3</span><span class="special">;</span> <span class="comment">// Named.</span>
</pre></div><div class="section" title="Named Function Parameters"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.named_function_parameters"></a><a class="link" href="#contract__.named_parameters.named_function_parameters" title="Named Function Parameters">Named
Function Parameters</a></h3></div></div></div><p>
To show how to program named parameters, we will program a named parameter
interface for the <a class="ulink" href="http://www.boost.org/doc/libs/1_49_0/libs/graph/doc/depth_first_search.html" target="_top">Depth
First Search (DFS)</a> algorithm of the <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/graph" target="_top">Boost.Graph</a>
library:
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">Graph</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">Visitor</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">IndexMap</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ColorMap</span>
<span class="special">&gt;</span> <span class="identifier">requires</span>
<span class="identifier">is_incidence_and_vertex_list_graph</span><span class="special">&lt;</span><span class="identifier">Graph</span><span class="special">&gt;,</span>
<span class="identifier">is_integral_property_map_of_key</span><span class="special">&lt;</span><span class="identifier">IndexMap</span><span class="special">,</span> <span class="identifier">vertext_descriptor</span><span class="special">&lt;</span><span class="identifier">Graph</span><span class="special">&gt;</span> <span class="special">&gt;,</span>
<span class="identifier">is_property_map_of_key</span><span class="special">&lt;</span><span class="identifier">ColorMap</span><span class="special">,</span> <span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">Graph</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">depth_first_search</span> <span class="special">(</span>
<span class="identifier">Graph</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">graph</span><span class="special">,</span>
<span class="identifier">Visitor</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">visitor</span> <span class="special">=</span> <span class="identifier">dfs_visitor</span><span class="special">&lt;&gt;(),</span>
<span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">Graph</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">root_vertex</span> <span class="special">=</span>
<span class="special">*</span><span class="identifier">vertices</span><span class="special">(</span><span class="identifier">graph</span><span class="special">).</span><span class="identifier">first</span><span class="special">,</span>
<span class="identifier">IndexMap</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">index_map</span> <span class="special">=</span> <span class="identifier">get</span><span class="special">(</span><span class="identifier">vertex_index</span><span class="special">,</span> <span class="identifier">graph</span><span class="special">),</span>
<span class="identifier">ColorMap</span><span class="special">&amp;</span> <span class="identifier">color_map</span> <span class="special">=</span>
<span class="identifier">default_color_map</span><span class="special">(</span><span class="identifier">num_vertices</span><span class="special">(</span><span class="identifier">graph</span><span class="special">),</span> <span class="identifier">index_map</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">;</span>
</pre><p>
This is non-valid C++ code but it can be considered pseudo-code to illustrate
the function interface that we need to program. The concept syntax <code class="computeroutput"><span class="identifier">requires</span></code> was <span class="quote">&#8220;<span class="quote">borrowed</span>&#8221;</span> here
to express parameter type requirements but a failure to satisfy such requirements
is intended to fail the function call resolution and not to cause a concept
error as usual.
</p><div class="variablelist"><p class="title"><b></b></p><dl><dt><span class="term"><code class="literal">graph</code></span></dt><dd><p>
This is an input parameter (<code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span></code>), its type must match a model
of both <code class="computeroutput"><span class="identifier">IndicenceGraph</span></code>
and <code class="computeroutput"><span class="identifier">VertexListGraph</span></code>,
and it has no default value (required parameter).
</p></dd><dt><span class="term"><code class="literal">visitor</code></span></dt><dd><p>
This is an input parameter (<code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span></code>), its type has no requirement,
and its value defaults to a DFS visitor (optional parameter).
</p></dd><dt><span class="term"><code class="literal">root_vertex</code></span></dt><dd><p>
This is an input parameter (<code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span></code>), its type must be <code class="computeroutput"><span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">Graph</span><span class="special">&gt;</span></code>,
and its value defaults to the first vertex of the specified graph (optional
parameter).
</p></dd><dt><span class="term"><code class="literal">index_map</code></span></dt><dd><p>
This is an input parameter (<code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span></code>), its type must match a model
of <code class="computeroutput"><span class="identifier">IntegralPropertyMap</span></code>
with key type <code class="computeroutput"><span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">Graph</span><span class="special">&gt;</span></code>, its value defaults to the vertex
index of the specified graph (optional parameter).
</p></dd><dt><span class="term"><code class="literal">color_map</code></span></dt><dd><p>
This is an input and output parameter (non-constant reference <code class="computeroutput"><span class="special">&amp;</span></code>), its type must match a model
of <code class="computeroutput"><span class="identifier">PropertyMap</span></code> with
key type <code class="computeroutput"><span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">Graph</span><span class="special">&gt;</span></code>, its value defaults to a map with
size equal to the number of vertices of the specified graph and created
from the specified <code class="computeroutput"><span class="identifier">index_map</span></code>
(optional parameter).
</p></dd></dl></div><p>
<span class="bold"><strong>Parameter Identifiers</strong></span>
</p><p>
First of all, it is necessary to declare special elements that will serve
as the parameter and argument identifiers (see also <a class="ulink" href="../../example/named_parameters/named_params_dfs.cpp" target="_top"><code class="literal">named_params_dfs.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">graphs</span> <span class="special">{</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">graph</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">visitor</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">root_vertex</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">index_map</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">color_map</span><span class="special">)</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
For example, the first <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code>
macro declares an identifier <code class="computeroutput"><span class="identifier">graph</span></code>
that is used as the parameter name in the function declaration and also an
identifier <code class="computeroutput"><span class="identifier">graph_</span></code> (note the
trailing underscore <code class="computeroutput"><span class="identifier">_</span></code>) that
is used to name the argument at the call site.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
By default, argument identifiers are differentiated from parameter identifiers
using a trailing underscore <code class="computeroutput"><span class="identifier">_</span></code>
to avoid name clashes (see also the <a class="link" href="#contract__.named_parameters.parameter_identifiers" title="Parameter Identifiers">Parameter
Identifiers</a> section). Furthermore, it is recommended to always declare
these identifiers within a namespace to avoid name clashes (because different
functions in different sections of the code might very well use the same
parameter names so namespaces can be used to control overlapping names).
</p></td></tr></table></div><p>
For example, for a library named Graphs, all named parameter identifiers
could be declared under the <code class="computeroutput"><span class="identifier">graphs</span></code>
namespace and maybe in a single header <code class="literal">graphs_params.hpp</code>.
Many different functions within <code class="computeroutput"><span class="identifier">graphs</span></code>
(for example <code class="computeroutput"><span class="identifier">graphs</span><span class="special">::</span><span class="identifier">depth_first_search</span></code> and <code class="computeroutput"><span class="identifier">graphs</span><span class="special">::</span><span class="identifier">breadth_first_search</span></code>)
will share a number of common parameter names (for example a parameter named
<code class="computeroutput"><span class="identifier">graph</span></code> with parameter identifier
<code class="computeroutput"><span class="identifier">graphs</span><span class="special">::</span><span class="identifier">graph</span></code> and argument identifier <code class="computeroutput"><span class="identifier">graphs</span><span class="special">::</span><span class="identifier">graph_</span></code>). All these named parameters will
be defined in one places in <code class="literal">graphs_params.hpp</code> and within
the <code class="computeroutput"><span class="identifier">graphs</span></code> namespace so programmers
can conveniently control and avoid named clashes.
</p><p>
<span class="bold"><strong>Function Declaration</strong></span>
</p><p>
The function is declared using the following syntax (see also <a class="ulink" href="../../example/named_parameters/named_params_dfs.cpp" target="_top"><code class="literal">named_params_dfs.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">graphs</span> <span class="special">{</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">depth_first_search</span><span class="special">)</span> <span class="special">(</span>
<span class="comment">// Required parameter (no default value) with requirement predicate.</span>
<span class="identifier">in</span> <span class="identifier">requires</span><span class="special">(</span><span class="identifier">is_incidence_and_vertex_list_graph</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;)</span>
<span class="identifier">graph</span><span class="special">,</span>
<span class="comment">// Optional (default value) of any type (auto).</span>
<span class="identifier">in</span> <span class="keyword">auto</span> <span class="identifier">visitor</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dfs_visitor</span><span class="special">&lt;&gt;(),</span>
<span class="comment">// Exact type specified.</span>
<span class="identifier">in</span> <span class="special">(</span><span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">CONTRACT_PARAMETER_TYPEOF</span><span class="special">(</span><span class="identifier">graph</span><span class="special">)&gt;)</span>
<span class="identifier">root_vertex</span><span class="special">,</span> <span class="keyword">default</span> <span class="special">(*</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">vertices</span><span class="special">(</span><span class="identifier">graph</span><span class="special">).</span><span class="identifier">first</span><span class="special">),</span>
<span class="comment">// Any type matching requirement predicate (unary meta-function).</span>
<span class="identifier">in</span> <span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">is_integral_property_map_of_key</span><span class="special">&lt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span>
<span class="special">,</span> <span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">CONTRACT_PARAMETER_TYPEOF</span><span class="special">(</span><span class="identifier">graph</span><span class="special">)&gt;</span>
<span class="special">&gt;</span>
<span class="special">)</span> <span class="identifier">index_map</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">vertex_index</span><span class="special">,</span> <span class="identifier">graph</span><span class="special">),</span>
<span class="comment">// In-out parameter.</span>
<span class="identifier">in</span> <span class="identifier">out</span> <span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">is_property_map_of_key</span><span class="special">&lt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span>
<span class="special">,</span> <span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">CONTRACT_PARAMETER_TYPEOF</span><span class="special">(</span><span class="identifier">graph</span><span class="special">)&gt;</span>
<span class="special">&gt;</span>
<span class="special">)</span> <span class="identifier">color_map</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">default_color_map</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">num_vertices</span><span class="special">(</span><span class="identifier">graph</span><span class="special">),</span>
<span class="identifier">index_map</span><span class="special">)</span>
<span class="special">)</span>
<span class="comment">// No `precondition(...)` or `postcondition(...)` in this example.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Also function definition can use `PARAMETER_TYPEOF`.</span>
<span class="keyword">typedef</span> <span class="identifier">CONTRACT_PARAMETER_TYPEOF</span><span class="special">(</span><span class="identifier">graph</span><span class="special">)&amp;</span> <span class="identifier">graph_ref</span><span class="special">;</span> <span class="comment">// Unused by example.</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">depth_first_search</span><span class="special">(</span><span class="identifier">graph</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">visitor</span><span class="special">(</span><span class="identifier">visitor</span><span class="special">).</span>
<span class="identifier">color_map</span><span class="special">(</span><span class="identifier">color_map</span><span class="special">).</span><span class="identifier">root_vertex</span><span class="special">(</span><span class="identifier">root_vertex</span><span class="special">).</span>
<span class="identifier">vertex_index_map</span><span class="special">(</span><span class="identifier">index_map</span><span class="special">));</span>
<span class="special">}</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
This example required no preconditions and no postconditions.
</p><p>
<span class="bold"><strong>In, In Out, and Out Parameters</strong></span>
</p><p>
Input parameters (i.e., constant references <code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span></code>) are prefixed by the specifier <code class="computeroutput"><span class="identifier">in</span></code> (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section):
</p><pre class="programlisting"><span class="identifier">in</span> <span class="special">...</span> <span class="identifier">graph</span> <span class="comment">// Input parameter.</span>
</pre><p>
Input and output parameters (i.e., non-constant reference <code class="computeroutput"><span class="special">&amp;</span></code>)
are prefixed by both specifiers <code class="computeroutput"><span class="identifier">in</span>
<span class="identifier">out</span></code> (in this order, see also the
<a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section):
</p><pre class="programlisting"><span class="identifier">in</span> <span class="identifier">out</span> <span class="special">...</span> <span class="identifier">color_map</span> <span class="comment">// Input-output parameter.</span>
</pre><p>
Output parameters can be prefixed just by the specifier <code class="computeroutput"><span class="identifier">out</span></code>
but their implementation is equivalent to using the specifiers <code class="computeroutput"><span class="identifier">in</span> <span class="identifier">out</span></code>
(i.e., non-constant reference <code class="computeroutput"><span class="special">&amp;</span></code>).
<sup>[<a name="contract__.named_parameters.named_function_parameters.f0" href="#ftn.contract__.named_parameters.named_function_parameters.f0" class="footnote">58</a>]</sup> Note that a named parameter must always be specified either
<code class="computeroutput"><span class="identifier">in</span></code>, <code class="computeroutput"><span class="identifier">in</span>
<span class="identifier">out</span></code>, or <code class="computeroutput"><span class="identifier">out</span></code>
(and that is what distinguish syntactically a named parameter from a positional
parameter; this use of <code class="computeroutput"><span class="identifier">in</span></code>,
<code class="computeroutput"><span class="identifier">in</span> <span class="identifier">out</span></code>,
and <code class="computeroutput"><span class="identifier">out</span></code> resembles <a class="ulink" href="http://en.wikipedia.org/wiki/Ada_(programming_language)" target="_top">Ada</a>'s
syntax). Named and positional parameters cannot be used together in the same
function declaration.
</p><p>
<span class="bold"><strong>Parameter Types</strong></span>
</p><p>
Exact parameter types are specified just before the parameter name and within
parenthesis (unless they are fundamental types containing no symbol, see
also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section):
</p><pre class="programlisting"><span class="identifier">in</span> <span class="special">(</span><span class="identifier">vertex_descriptor</span><span class="special">&lt;</span><span class="identifier">CONTRACT_PARAMETER_TYPEOF</span><span class="special">(</span><span class="identifier">graph</span><span class="special">)&gt;)</span> <span class="identifier">root_vertex</span> <span class="comment">// Exact parameter type requirement.</span>
</pre><p>
Generic parameter types (i.e., parameter types with no requirement, same
as usual type template parameters) are specified using <code class="computeroutput"><span class="keyword">auto</span></code>
instead of the parameter type (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section):
</p><pre class="programlisting"><span class="identifier">in</span> <span class="keyword">auto</span> <span class="identifier">visitor</span> <span class="comment">// No parameter type requirement.</span>
</pre><p>
Predicate parameter type requirements are specified using <code class="computeroutput"><span class="identifier">requires</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>unary-boolean-metafunction</em></span></code><code class="computeroutput"><span class="special">)</span></code> instead of the parameter type, the type
of the argument specified by the function call will be required to match
the specified unary boolean meta-function in order for the call to be resolved
(see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section):
</p><pre class="programlisting"><span class="identifier">in</span> <span class="identifier">requires</span><span class="special">(</span><span class="identifier">is_incidence_and_vertex_list_graph</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;)</span> <span class="identifier">graph</span> <span class="comment">// Predicate parameter type requirement.</span>
</pre><p>
The placeholder <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span></code>
makes this expression a unary meta-function (see <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/mpl" target="_top">Boost.MPL</a>)
and the library will substitute such a placeholder with the argument type
specified at the call site when resolving the function call.
</p><p>
<span class="bold"><strong>Default Parameter Values</strong></span>
</p><p>
Default parameter values are specified using <code class="computeroutput"><span class="special">,</span>
<span class="keyword">default</span> </code><code class="literal"><span class="emphasis"><em>default-parameter-value</em></span></code>
right after the parameter declaration (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section):
</p><pre class="programlisting"><span class="identifier">in</span> <span class="keyword">auto</span> <span class="identifier">visitor</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dfs_visitor</span><span class="special">&lt;&gt;()</span>
</pre><p>
Default parameter values are not evaluated and their types are not even instantiated
if an actual argument is specified by the function call.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
The type and value of a parameters can be used within the declaration of
other parameters. The type of a named parameter can be accessed using the
<code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_TYPEOF" title="Macro CONTRACT_PARAMETER_TYPEOF">CONTRACT_PARAMETER_TYPEOF</a></code>
macro (this is especially useful for generic parameter types and for parameter
types with predicate requirements because these types are not known until
the function call is resolved).
</p></td></tr></table></div><p>
<span class="bold"><strong>Function Call</strong></span>
</p><p>
The <code class="computeroutput"><span class="identifier">graphs</span><span class="special">::</span><span class="identifier">depth_first_search</span></code> function can be called
using argument identifiers to name its parameters (see also <a class="ulink" href="../../example/named_parameters/named_params_dfs.cpp" target="_top"><code class="literal">named_params_dfs.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">graphs</span><span class="special">::</span><span class="identifier">depth_first_search</span><span class="special">(</span><span class="identifier">graphs</span><span class="special">::</span><span class="identifier">visitor_</span> <span class="special">=</span> <span class="identifier">vis</span><span class="special">,</span> <span class="identifier">graphs</span><span class="special">::</span><span class="identifier">graph_</span> <span class="special">=</span> <span class="identifier">g</span><span class="special">);</span>
</pre><p>
</p></div><div class="section" title="Deduced Function Parameters"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.deduced_function_parameters"></a><a class="link" href="#contract__.named_parameters.deduced_function_parameters" title="Deduced Function Parameters">Deduced
Function Parameters</a></h3></div></div></div><p>
To show how to program deduced named parameters, we program the parameter
interface for the <a class="ulink" href="http://www.boost.org/doc/libs/1_49_0/libs/python/doc/v2/def.html#def-spec" target="_top"><code class="computeroutput"><span class="identifier">def</span></code></a> function of the <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/python" target="_top">Boost.Python</a>
library (see also <a class="ulink" href="../../example/named_parameters/deduced_params_pydef.cpp" target="_top"><code class="literal">deduced_params_pydef.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">py</span> <span class="special">{</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">func</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">docstring</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">keywords</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">policies</span><span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">def</span><span class="special">)</span> <span class="special">(</span>
<span class="comment">// Non-deduced (and also required) named parameters.</span>
<span class="identifier">in</span> <span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="identifier">name</span><span class="special">,</span>
<span class="identifier">in</span> <span class="keyword">auto</span> <span class="identifier">func</span><span class="special">,</span>
<span class="comment">// Deduced (and also optional) named parameters.</span>
<span class="identifier">deduce</span> <span class="identifier">in</span> <span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="identifier">docstring</span><span class="special">,</span> <span class="keyword">default</span> <span class="special">(</span><span class="string">""</span><span class="special">),</span>
<span class="identifier">deduce</span> <span class="identifier">in</span> <span class="identifier">requires</span><span class="special">(</span><span class="identifier">is_keyword_expression</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;)</span> <span class="identifier">keywords</span><span class="special">,</span>
<span class="keyword">default</span> <span class="identifier">no_keywords</span><span class="special">(),</span>
<span class="comment">// Type requirements also used to uniquely deduce parameters.</span>
<span class="identifier">deduce</span> <span class="identifier">in</span> <span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">not_</span><span class="special">&lt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">or_</span><span class="special">&lt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;</span>
<span class="special">,</span> <span class="identifier">is_keyword_expression</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;</span>
<span class="special">&gt;</span>
<span class="special">&gt;</span>
<span class="special">)</span> <span class="identifier">policies</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">default_call_policies</span><span class="special">()</span>
<span class="comment">// Concepts for named parameters.</span>
<span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <span class="identifier">CallPolicies</span><span class="special">&lt;</span><span class="identifier">CONTRACT_PARAMETER_TYPEOF</span><span class="special">(</span><span class="identifier">policies</span><span class="special">)&gt;</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">is_identifier</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// Contracts.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">func</span><span class="special">,</span> <span class="identifier">docstring</span><span class="special">,</span> <span class="identifier">keywords</span><span class="special">,</span> <span class="identifier">policies</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
Also a precondition was specified in this example. (Concepts for named parameters
are explained later in this section.)
</p><p>
Deduced parameters are named parameter that are prefixed by the <code class="computeroutput"><span class="identifier">deduce</span></code> specifier (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section):
</p><pre class="programlisting"><span class="identifier">deduce</span> <span class="identifier">in</span> <span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="identifier">docstring</span> <span class="comment">// Deduced input parameter.</span>
</pre><p>
When calling the function <code class="computeroutput"><span class="identifier">py</span><span class="special">::</span><span class="identifier">def</span></code> only
two arguments are required <code class="computeroutput"><span class="identifier">name</span></code>
and <code class="computeroutput"><span class="identifier">func</span></code>. The association
between any addition argument and its parameter can be deduced based on the
types of the arguments specified by the function call (so the caller is neither
required to remember the parameter positions nor to explicitly specify the
parameter names for these arguments).
</p><p>
For example, the first two calls below are equivalent and if programmers
need to pass a <code class="computeroutput"><span class="identifier">policy</span></code> argument
that is also, for some reason, convertible to <code class="computeroutput"><span class="keyword">char</span>
<span class="keyword">const</span><span class="special">*</span></code>,
they can always specify the parameter name as in the third call below (see
also <a class="ulink" href="../../example/named_parameters/deduced_params_pydef.cpp" target="_top"><code class="literal">deduced_params_pydef.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">py</span><span class="special">::</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">print</span><span class="special">&lt;</span><span class="char">'f'</span><span class="special">&gt;,</span> <span class="identifier">nonstring_policies</span><span class="special">,</span> <span class="string">"Documentation for f"</span><span class="special">);</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">def</span><span class="special">(</span><span class="string">"g"</span><span class="special">,</span> <span class="identifier">print</span><span class="special">&lt;</span><span class="char">'g'</span><span class="special">&gt;,</span> <span class="string">"Documentation for g"</span><span class="special">,</span> <span class="identifier">nonstring_policies</span><span class="special">);</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">def</span><span class="special">(</span><span class="string">"h"</span><span class="special">,</span> <span class="identifier">print</span><span class="special">&lt;</span><span class="char">'h'</span><span class="special">&gt;,</span> <span class="identifier">py</span><span class="special">::</span><span class="identifier">policies_</span> <span class="special">=</span> <span class="identifier">string_policies</span><span class="special">,</span>
<span class="string">"Documentation for h"</span><span class="special">);</span>
</pre><p>
</p></div><div class="section" title="Member Function Parameters"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.member_function_parameters"></a><a class="link" href="#contract__.named_parameters.member_function_parameters" title="Member Function Parameters">Member
Function Parameters</a></h3></div></div></div><p>
The same syntax is used to specify named and deduced parameters for member
functions (see also <a class="ulink" href="../../example/named_parameters/member_named_params_callable2.cpp" target="_top"><code class="literal">member_named_params_callable2.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">calls</span> <span class="special">{</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">arg2</span><span class="special">)</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">callable2</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Member function with named parameters.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">call</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">in</span> <span class="keyword">int</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">in</span> <span class="keyword">int</span> <span class="identifier">arg2</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Body definition can be separated...</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Constant member with named parameters.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">call</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">in</span> <span class="keyword">int</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">in</span> <span class="keyword">int</span> <span class="identifier">arg2</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">total</span> <span class="special">=</span> <span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Static member with named parameters.</span>
<span class="keyword">public</span> <span class="keyword">static</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">static_call</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">in</span> <span class="keyword">int</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">in</span> <span class="keyword">int</span> <span class="identifier">arg2</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">total</span> <span class="special">=</span> <span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">static</span> <span class="keyword">int</span> <span class="identifier">total</span><span class="special">;</span>
<span class="special">};</span>
<span class="comment">// ... but body definition uses template parameters and special `BODY` macro.</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">Arg1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Arg2</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">callable2</span><span class="special">::</span><span class="identifier">CONTRACT_PARAMETER_BODY</span><span class="special">(</span><span class="identifier">call</span><span class="special">)(</span> <span class="identifier">Arg1</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">Arg2</span> <span class="identifier">arg2</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">total</span> <span class="special">=</span> <span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">callable2</span><span class="special">::</span><span class="identifier">total</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
No contracts were specified in this example.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
When the body definition of a function with named parameters is deferred
from the function declaration, the body must be declared as a template
function when it is defined and the special macro <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_BODY" title="Macro CONTRACT_PARAMETER_BODY">CONTRACT_PARAMETER_BODY</a></code>
must be used to name the function.
</p></td></tr></table></div><p>
The same macro is used to name both free and member body functions because
the class type is specified outside this macro. The constructor body definition
cannot be deferred from the constructor declaration (because of the lack
of delegating constructors in <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>).
Destructors have no named parameters (because they have no parameter). Named
parameters are not supported for operators (because of a <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
bug). <sup>[<a name="contract__.named_parameters.member_function_parameters.f0" href="#ftn.contract__.named_parameters.member_function_parameters.f0" class="footnote">59</a>]</sup> Therefore the <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_BODY" title="Macro CONTRACT_PARAMETER_BODY">CONTRACT_PARAMETER_BODY</a></code>
macro is used only with free and member functions that are not operators.
<sup>[<a name="contract__.named_parameters.member_function_parameters.f1" href="#ftn.contract__.named_parameters.member_function_parameters.f1" class="footnote">60</a>]</sup>
</p><p>
In this example, named parameters were specified for all <code class="computeroutput"><span class="identifier">callable2</span><span class="special">::</span><span class="identifier">call</span></code>
overloads and for the <code class="computeroutput"><span class="keyword">static</span></code>
member function <code class="computeroutput"><span class="identifier">callable2</span><span class="special">:</span><span class="identifier">static_call</span></code>:
</p><p>
</p><pre class="programlisting"><span class="identifier">calls</span><span class="special">::</span><span class="identifier">callable2</span><span class="special">::</span><span class="identifier">static_call</span><span class="special">(</span><span class="identifier">calls</span><span class="special">::</span><span class="identifier">arg2_</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="identifier">calls</span><span class="special">::</span><span class="identifier">arg1_</span> <span class="special">=</span> <span class="number">1</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">calls</span><span class="special">::</span><span class="identifier">callable2</span><span class="special">::</span><span class="identifier">total</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">calls</span><span class="special">::</span><span class="identifier">callable2</span> <span class="identifier">c</span><span class="special">;</span>
<span class="identifier">c</span><span class="special">.</span><span class="identifier">call</span><span class="special">(</span><span class="identifier">calls</span><span class="special">::</span><span class="identifier">arg2_</span> <span class="special">=</span> <span class="number">3</span><span class="special">,</span> <span class="identifier">calls</span><span class="special">::</span><span class="identifier">arg1_</span> <span class="special">=</span> <span class="number">4</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">calls</span><span class="special">::</span><span class="identifier">callable2</span><span class="special">::</span><span class="identifier">total</span> <span class="special">==</span> <span class="number">7</span><span class="special">);</span>
<span class="identifier">calls</span><span class="special">::</span><span class="identifier">callable2</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">cc</span> <span class="special">=</span> <span class="identifier">c</span><span class="special">;</span>
<span class="identifier">cc</span><span class="special">.</span><span class="identifier">call</span><span class="special">(</span><span class="identifier">calls</span><span class="special">::</span><span class="identifier">arg2_</span> <span class="special">=</span> <span class="number">5</span><span class="special">,</span> <span class="identifier">calls</span><span class="special">::</span><span class="identifier">arg1_</span> <span class="special">=</span> <span class="number">6</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">calls</span><span class="special">::</span><span class="identifier">callable2</span><span class="special">::</span><span class="identifier">total</span> <span class="special">==</span> <span class="number">11</span><span class="special">);</span>
</pre><p>
</p></div><div class="section" title="Constructor Parameters"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.constructor_parameters"></a><a class="link" href="#contract__.named_parameters.constructor_parameters" title="Constructor Parameters">Constructor
Parameters</a></h3></div></div></div><p>
The same syntax is used to specify named and deduced parameters for constructors
(see also <a class="ulink" href="../../example/named_parameters/constructor_named_params_family.cpp" target="_top"><code class="literal">constructor_named_params_family.cpp</code></a>):
<sup>[<a name="contract__.named_parameters.constructor_parameters.f0" href="#ftn.contract__.named_parameters.constructor_parameters.f0" class="footnote">61</a>]</sup>
</p><p>
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">family</span> <span class="special">{</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">age</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">relatives</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">weight</span><span class="special">)</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">member</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">person</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">member</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">in</span> <span class="keyword">auto</span> <span class="identifier">name</span><span class="special">,</span>
<span class="identifier">in</span> <span class="identifier">out</span> <span class="keyword">auto</span> <span class="identifier">age</span><span class="special">,</span> <span class="comment">//default 32,</span>
<span class="identifier">deduce</span> <span class="identifier">out</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">person</span><span class="special">&gt;)</span> <span class="identifier">relatives</span><span class="special">,</span>
<span class="identifier">deduce</span> <span class="identifier">in</span> <span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span>
<span class="special">)</span> <span class="identifier">weight</span> <span class="comment">//, default(75.0)</span>
<span class="special">)</span> <span class="comment">// Preconditions, body, etc access arguments as usual...</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span> <span class="special">!=</span> <span class="string">""</span><span class="special">,</span> <span class="identifier">age</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">weight</span> <span class="special">&gt;=</span> <span class="number">0.0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_relatives_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">relatives</span><span class="special">.</span><span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">relatives</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_relatives_size</span> <span class="special">+</span> <span class="number">1</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="comment">// ... but initializers must use the `..._ARG` macro.</span>
<span class="identifier">person</span><span class="special">(</span><span class="identifier">CONTRACT_CONSTRUCTOR_ARG</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_ARG</span><span class="special">(</span><span class="identifier">age</span><span class="special">),</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_ARG</span><span class="special">(</span><span class="identifier">weight</span><span class="special">)),</span>
<span class="identifier">family_</span><span class="special">(</span><span class="identifier">CONTRACT_CONSTRUCTOR_ARG</span><span class="special">(</span><span class="identifier">relatives</span><span class="special">))</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">relatives</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(*</span><span class="keyword">this</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">person</span><span class="special">&gt;&amp;</span> <span class="identifier">family_</span><span class="special">;</span>
<span class="special">};</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
Both preconditions and postconditions were specified for the constructor.
</p><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
Member initializers must access named and deduced parameters using the
special macro <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_ARG" title="Macro CONTRACT_CONSTRUCTOR_ARG">CONTRACT_CONSTRUCTOR_ARG</a></code>
(otherwise the compiler will generate an error). <sup>[<a name="contract__.named_parameters.constructor_parameters.f1" href="#ftn.contract__.named_parameters.constructor_parameters.f1" class="footnote">62</a>]</sup>
</p></td></tr></table></div><p>
Named and deduced parameters can be used to specify the arguments when constructing
the object:
</p><p>
</p><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">family</span><span class="special">::</span><span class="identifier">person</span><span class="special">&gt;</span> <span class="identifier">r</span><span class="special">;/*</span>
<span class="identifier">family</span><span class="special">::</span><span class="identifier">member</span> <span class="identifier">m1</span><span class="special">(</span><span class="identifier">family</span><span class="special">::</span><span class="identifier">name_</span> <span class="special">=</span> <span class="string">"Mary"</span><span class="special">,</span> <span class="identifier">family</span><span class="special">::</span><span class="identifier">relatives_</span> <span class="special">=</span> <span class="identifier">r</span><span class="special">);</span>
</pre><p>
</p></div><div class="section" title="Class Template Parameters"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.class_template_parameters"></a><a class="link" href="#contract__.named_parameters.class_template_parameters" title="Class Template Parameters">Class
Template Parameters</a></h3></div></div></div><p>
Only class templates are discussed in this section because function templates
are effectively always declared when a function uses named or deduced parameters.
In fact, a function with named or deduced parameters is always a function
template (possibly with fully generic templated types when the named and
deduced parameters types are specified <code class="computeroutput"><span class="keyword">auto</span></code>).
</p><p>
To show how to program named and deduced template parameters, we will program
a named parameter interface for the <a class="ulink" href="http://www.boost.org/doc/libs/1_49_0/libs/python/doc/v2/class.html#class_-spec" target="_top"><code class="computeroutput"><span class="identifier">class_</span></code></a> class template of the <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/python" target="_top">Boost.Python</a>
library:
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ClassType</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">Bases</span> <span class="special">=</span> <span class="identifier">bases</span><span class="special">&lt;&gt;,</span>
<span class="keyword">typename</span> <span class="identifier">HeldType</span> <span class="special">=</span> <span class="identifier">not_sepcified</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">Copyable</span> <span class="special">=</span> <span class="identifier">not_specified</span>
<span class="special">&gt;</span> <span class="identifier">requires</span>
<span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">ClassType</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">class_</span> <span class="special">;</span>
</pre><div class="variablelist"><p class="title"><b></b></p><dl><dt><span class="term">ClassType</span></dt><dd><p>
This type parameter must be a class and it has no default value (required
parameter).
</p></dd><dt><span class="term">Bases</span></dt><dd><p>
This type parameter must be a specialization of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">bases</span></code>
specifying base classes if any (see <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">specifies_bases</span></code>)
and its value defaults to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">bases</span><span class="special">&lt;&gt;</span></code>.
</p></dd><dt><span class="term">HeldType</span></dt><dd><p>
This type parameter has no constraint and it is not specified by default
(see <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">not_specified</span></code>).
</p></dd><dt><span class="term">Copyable</span></dt><dd><p>
This type parameter must be <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span></code>
if specified and it is not specified by default (see <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">not_specified</span></code>).
</p></dd></dl></div><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
Unfortunately, named and deduced template parameters can only handle type
template parameters (i.e., value template parameters and template template
parameters are not supported). <sup>[<a name="contract__.named_parameters.class_template_parameters.f0" href="#ftn.contract__.named_parameters.class_template_parameters.f0" class="footnote">63</a>]</sup>
</p></td></tr></table></div><p>
First of all, it is necessary to declare elements that will serve as template
parameter and argument identifiers (see also <a class="ulink" href="../../example/named_parameters/named_template_params_pyclass.cpp" target="_top"><code class="literal">named_template_params_pyclass.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">py</span> <span class="special">{</span>
<span class="identifier">CONTRACT_TEMPLATE_PARAMETER</span><span class="special">(</span><span class="identifier">ClassType</span><span class="special">)</span>
<span class="identifier">CONTRACT_TEMPLATE_PARAMETER</span><span class="special">(</span><span class="identifier">Bases</span><span class="special">)</span>
<span class="identifier">CONTRACT_TEMPLATE_PARAMETER</span><span class="special">(</span><span class="identifier">HeldType</span><span class="special">)</span>
<span class="identifier">CONTRACT_TEMPLATE_PARAMETER</span><span class="special">(</span><span class="identifier">Copyable</span><span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p><p>
For example, the first <code class="computeroutput"><a class="link" href="#CONTRACT_TEMPLATE_PARAMETER" title="Macro CONTRACT_TEMPLATE_PARAMETER">CONTRACT_TEMPLATE_PARAMETER</a></code>
macro declares a specifier <code class="computeroutput"><span class="identifier">ClassType</span></code>
that can be used as the parameter name in the class template declaration
and a specifier <code class="computeroutput"><span class="identifier">ClassType_</span></code>
(note the trailing underscore <code class="computeroutput"><span class="identifier">_</span></code>)
that can be used for the template argument at the template instantiation
site.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
By default, template argument identifiers are differentiated from template
parameter identifiers using a trailing underscore <code class="computeroutput"><span class="identifier">_</span></code>
to avoid name clashes (see also the <a class="link" href="#contract__.named_parameters.parameter_identifiers" title="Parameter Identifiers">Parameter
Identifiers</a> section). Furthermore, it is recommended to always declare
these identifiers within a namespace to avoid name clashes (because different
class templates in different sections of the code might very well use the
same template parameter names so namespaces can be used to control overlapping
names).
</p></td></tr></table></div><p>
The class template is declared using a syntax similar to the one we have
seen so far for named and deduced function parameters (see also <a class="ulink" href="../../example/named_parameters/named_template_params_pyclass.cpp" target="_top"><code class="literal">named_template_params_pyclass.cpp</code></a>):
<sup>[<a name="contract__.named_parameters.class_template_parameters.f1" href="#ftn.contract__.named_parameters.class_template_parameters.f1" class="footnote">64</a>]</sup>
</p><p>
</p><pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">py</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span>
<span class="comment">// Required named template parameter.</span>
<span class="identifier">in</span> <span class="keyword">typename</span> <span class="identifier">requires</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;)</span> <span class="identifier">ClassType</span><span class="special">,</span>
<span class="comment">// Optional deduced named template parameters with requirements.</span>
<span class="identifier">deduce</span> <span class="identifier">in</span> <span class="keyword">typename</span> <span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">specifies_bases</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;</span>
<span class="special">)</span> <span class="identifier">Bases</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">bases</span><span class="special">&lt;&gt;,</span>
<span class="identifier">deduce</span> <span class="identifier">in</span> <span class="keyword">typename</span> <span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">not_</span><span class="special">&lt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">or_</span><span class="special">&lt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">specifies_bases</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;</span>
<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;</span>
<span class="special">&gt;</span>
<span class="special">&gt;</span>
<span class="special">)</span> <span class="identifier">HeldType</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">not_specified</span><span class="special">,</span>
<span class="identifier">deduce</span> <span class="identifier">in</span> <span class="keyword">typename</span> <span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;</span>
<span class="special">)</span> <span class="identifier">Copyable</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">not_specified</span>
<span class="comment">// Unfortunately, non-type named template parameters are not supported.</span>
<span class="comment">// Concepts named template parameters.</span>
<span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">DefaultConstructible</span><span class="special">&lt;</span><span class="identifier">ClassType</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">class_</span><span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">ClassType</span><span class="special">,</span> <span class="identifier">Bases</span><span class="special">,</span> <span class="identifier">HeldType</span><span class="special">,</span> <span class="identifier">Copyable</span><span class="special">&gt;)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Contracts.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="identifier">ClassType</span> <span class="identifier">class_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="identifier">Bases</span> <span class="identifier">bases</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="identifier">HeldType</span> <span class="identifier">held_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="identifier">Copyable</span> <span class="identifier">copyable</span><span class="special">;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">class_</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">in</span> <span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="identifier">name</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">is_identifier</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span>
<span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">ClassType</span><span class="special">,</span> <span class="identifier">Bases</span><span class="special">,</span> <span class="identifier">HeldType</span><span class="special">,</span> <span class="identifier">Copyable</span><span class="special">&gt;(</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_ARG</span><span class="special">(</span><span class="identifier">name</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="comment">// namespace</span>
</pre><p>
</p><p>
Note that template parameters are always specified using <code class="computeroutput"><span class="identifier">in</span></code>
because they are always input parameters (they are static types). Furthermore,
<code class="computeroutput"><span class="keyword">typename</span></code> or <code class="computeroutput"><span class="keyword">class</span></code>
must always follow the <code class="computeroutput"><span class="identifier">in</span></code>
specifier for type template parameters. <sup>[<a name="contract__.named_parameters.class_template_parameters.f2" href="#ftn.contract__.named_parameters.class_template_parameters.f2" class="footnote">65</a>]</sup> Predicate type requirements <code class="computeroutput"><span class="identifier">requires</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>unary-boolean-metafunction</em></span></code><code class="computeroutput"><span class="special">)</span></code> are optional and they are specified right
after <code class="computeroutput"><span class="keyword">typename</span></code> or <code class="computeroutput"><span class="keyword">class</span></code> if present. Default template parameter
values are specified using <code class="computeroutput"><span class="special">,</span> <span class="keyword">default</span> </code><code class="literal"><span class="emphasis"><em>default-parameter-value</em></span></code>
as usual. (See also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section.)
</p><p>
The class template <code class="computeroutput"><span class="identifier">py</span><span class="special">::</span><span class="identifier">class_</span></code> can be instantiated using the template
parameter identifiers to name the arguments (see also <a class="ulink" href="../../example/named_parameters/named_template_params_pyclass.cpp" target="_top"><code class="literal">named_template_params_pyclass.cpp</code></a>):
<sup>[<a name="contract__.named_parameters.class_template_parameters.f3" href="#ftn.contract__.named_parameters.class_template_parameters.f3" class="footnote">66</a>]</sup>
</p><p>
</p><pre class="programlisting"><span class="comment">// Named parameters.</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">py</span><span class="special">::</span><span class="identifier">ClassType_</span><span class="special">&lt;</span><span class="identifier">bx</span><span class="special">&gt;,</span> <span class="identifier">py</span><span class="special">::</span><span class="identifier">Copyable_</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"bx"</span><span class="special">);</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">py</span><span class="special">::</span><span class="identifier">HeldType_</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">x</span><span class="special">&gt;</span> <span class="special">&gt;,</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">Bases_</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">bx</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"x"</span><span class="special">);</span>
<span class="comment">// Deduced parameters.</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">by</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"by"</span><span class="special">);</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">y</span><span class="special">&gt;,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">::</span><span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">by</span><span class="special">&gt;</span> <span class="special">&gt;(</span>
<span class="identifier">py</span><span class="special">::</span><span class="identifier">name_</span> <span class="special">=</span> <span class="string">"y"</span><span class="special">);</span>
</pre><p>
</p></div><div class="section" title="Concepts"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.concepts"></a><a class="link" href="#contract__.named_parameters.concepts" title="Concepts">Concepts</a></h3></div></div></div><p>
As shown in the <code class="computeroutput"><span class="identifier">py</span><span class="special">::</span><span class="identifier">class_</span></code> example above, it is possible to
specify concepts for named and deduced template parameters. Concepts are
specified using <code class="computeroutput"><span class="identifier">requires</span></code>
after the class template parameter declaration:
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <code class="literal"><span class="emphasis"><em>concept1</em></span></code><span class="special">,</span> <code class="literal"><span class="emphasis"><em>concept2</em></span></code><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">class_</span><span class="special">)</span> <span class="special">...</span>
</pre><p>
As shown in the <code class="computeroutput"><span class="identifier">py</span><span class="special">::</span><span class="identifier">def</span></code> example earlier in this section, it
is also possible to specify concepts for named and deduced function parameters
(because named and deduced function parameter can be generic, as function
template parameters are, when their types are specified <code class="computeroutput"><span class="keyword">auto</span></code>
or via a predicate type requirement). However, in this case concepts are
specified using <code class="computeroutput"><span class="identifier">requires</span></code>
after the function parameter list (because there is not <code class="computeroutput"><span class="keyword">template</span></code>
declaration for functions with named and deduced parameters):
</p><pre class="programlisting"><span class="keyword">void</span> <span class="special">(</span><span class="identifier">def</span><span class="special">)</span> <span class="special">(</span> <span class="special">...</span> <span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <code class="literal"><span class="emphasis"><em>concept1</em></span></code><span class="special">,</span> <code class="literal"><span class="emphasis"><em>concept2</em></span></code><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
</pre><p>
Note the following differences between specifying predicate type requirements
and concepts for named and deduced parameters:
</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
If predicate type requirements are not met, the function or class template
will be taken out from the set of possible function overloads or template
specializations in the function call or template instantiation resolution
(this might ultimately generate a compiler error but only if there is
no other function overload or template specialization that can be used).
</li><li class="listitem">
If a concept check fails, the compiler will always generate a compiler
error.
</li></ul></div></div><div class="section" title="Parameter Identifiers"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.named_parameters.parameter_identifiers"></a><a class="link" href="#contract__.named_parameters.parameter_identifiers" title="Parameter Identifiers">Parameter
Identifiers</a></h3></div></div></div><p>
When using the <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_TEMPLATE_PARAMETER" title="Macro CONTRACT_TEMPLATE_PARAMETER">CONTRACT_TEMPLATE_PARAMETER</a></code>
macros (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section):
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
It is possible to specify a namespace that will contain the parameter
identifiers using <code class="computeroutput"><span class="keyword">namespace</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>parameter-identifier-namespace</em></span></code><code class="computeroutput"><span class="special">)</span></code>.
</li><li class="listitem">
It is also possible to specify the name of the argument identifier instead
of using the automatic underscore <code class="computeroutput"><span class="identifier">_</span></code>
postfix using <code class="computeroutput"><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>argument-identifier</em></span></code><code class="computeroutput"><span class="special">)</span></code>.
</li></ol></div><p>
The following example generates parameter identifiers within the <code class="computeroutput"><span class="identifier">params</span></code> namespace, and argument identifiers
<code class="computeroutput"><span class="identifier">NumberArg</span></code> and <code class="computeroutput"><span class="identifier">value_arg</span></code> instead of the default <code class="computeroutput"><span class="identifier">Number_</span></code> and <code class="computeroutput"><span class="identifier">value_</span></code>
for the <code class="computeroutput"><span class="identifier">Number</span></code> and <code class="computeroutput"><span class="identifier">value</span></code> parameters respectively (see also
<a class="ulink" href="../../example/named_parameters/named_param_identifiers_positive.cpp" target="_top"><code class="literal">named_param_identifiers_positive.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_TEMPLATE_PARAMETER</span><span class="special">(</span> <span class="keyword">namespace</span><span class="special">(</span><span class="identifier">params</span><span class="special">)</span> <span class="special">(</span><span class="identifier">NumberArg</span><span class="special">)</span> <span class="identifier">Number</span> <span class="special">)</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span> <span class="keyword">namespace</span><span class="special">(</span><span class="identifier">params</span><span class="special">)</span> <span class="special">(</span><span class="identifier">value_arg</span><span class="special">)</span> <span class="identifier">value</span> <span class="special">)</span>
</pre><p>
</p><p>
When the parameter identifier namespace is specified, it must be repeated
in the named and deduced parameter declaration list (see also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section):
</p><pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="emphasis"><em>paraemeter-identifier-namespace</em></span><span class="special">,</span> <span class="special">...</span> <span class="comment">// named and deduced parameters follow</span>
</pre><p>
The authors find this syntax confusing so they recommend to never specify
the parameter identifier namespace when using the <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_TEMPLATE_PARAMETER" title="Macro CONTRACT_TEMPLATE_PARAMETER">CONTRACT_TEMPLATE_PARAMETER</a></code>
macros. <sup>[<a name="contract__.named_parameters.parameter_identifiers.f0" href="#ftn.contract__.named_parameters.parameter_identifiers.f0" class="footnote">67</a>]</sup> macro. ] Instead programmers are encouraged to use these macros
within an enclosing namespace as done by the rest of the examples in this
documentation.
</p><p>
For example (see also <a class="ulink" href="../../example/named_parameters/named_param_identifiers_positive.cpp" target="_top"><code class="literal">named_param_identifiers_positive.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="comment">// Named template parameters must specify `params` namespace.</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">params</span><span class="special">,</span> <span class="identifier">in</span> <span class="keyword">typename</span> <span class="identifier">Number</span> <span class="special">)</span>
<span class="keyword">struct</span> <span class="special">(</span><span class="identifier">positive</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">get</span><span class="special">()</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="comment">// Named parameters must specify `params` namespace.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">positive</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">params</span><span class="special">,</span> <span class="identifier">in</span> <span class="special">(</span><span class="identifier">Number</span><span class="special">)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">value</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">get</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">value_</span><span class="special">(</span><span class="identifier">CONTRACT_CONSTRUCTOR_ARG</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="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">Number</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">get</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">Number</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p><p>
Class invariants, preconditions, and postconditions were also specified in
this example.
</p><p>
At the template instantiation and function call site, the specified argument
identifiers <code class="computeroutput"><span class="identifier">NumberArg</span></code> and
<code class="computeroutput"><span class="identifier">value_arg</span></code> can be used instead
of the usual trailing underscore (see also <a class="ulink" href="../../example/named_parameters/named_param_identifiers_positive.cpp" target="_top"><code class="literal">named_param_identifiers_positive.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">positive</span><span class="special">&lt;</span><span class="identifier">NumberArg</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">n</span><span class="special">(</span><span class="identifier">value_arg</span> <span class="special">=</span> <span class="number">123</span><span class="special">);</span> <span class="comment">// Use ...Arg and ..._arg.</span>
</pre><p>
</p><p>
It is not necessary to specify both the parameter identifier namespace and
the argument identifier as they are both and independently optional (see
also the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a> section):
</p><pre class="programlisting"><span class="identifier">CONTRACT_TEMPLATE_PARAMETER</span><span class="special">(</span> <span class="special">(</span><span class="identifier">NumberArg</span><span class="special">)</span> <span class="identifier">Number</span> <span class="special">)</span> <span class="comment">// Specify only argument identifier.</span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span> <span class="keyword">namespace</span><span class="special">(</span><span class="identifier">params</span><span class="special">)</span> <span class="identifier">value</span> <span class="special">)</span> <span class="comment">// Specify only parameter identifier namespace.</span>
</pre><p>
It is recommended to never specify the argument identifiers to have the same
names as the parameter identifiers in order to avoid the following usually
silent bug (see also <a class="ulink" href="../../example/named_parameters/named_param_identifiers_failure.cpp" target="_top"><code class="literal">named_param_identifiers_failure.cpp</code></a>):
</p><p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span> <span class="special">(</span><span class="identifier">name</span><span class="special">)</span> <span class="identifier">name</span> <span class="special">)</span> <span class="comment">// Both parameter and argument </span>
<span class="identifier">CONTRACT_PARAMETER</span><span class="special">(</span> <span class="special">(</span><span class="identifier">age</span><span class="special">)</span> <span class="identifier">age</span> <span class="special">)</span> <span class="comment">// have same name, but...</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">print</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">in</span> <span class="keyword">auto</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">default</span><span class="special">(</span><span class="string">"bob"</span><span class="special">),</span> <span class="identifier">in</span> <span class="keyword">auto</span> <span class="identifier">age</span><span class="special">,</span> <span class="keyword">default</span> <span class="number">42</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">age</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">age</span> <span class="special">&gt;=</span> <span class="number">40</span><span class="special">)</span> <span class="keyword">throw</span> <span class="identifier">too_old</span><span class="special">();</span> <span class="comment">// Will throw because age defaulted to 42.</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">f</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">age</span> <span class="special">)</span> <span class="comment">// Another parameter with the same name.</span>
<span class="special">{</span>
<span class="identifier">print</span><span class="special">(</span><span class="identifier">age</span> <span class="special">=</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// So incorrect call but no compiler-error.</span>
<span class="special">}</span>
</pre><p>
</p><p>
The call <code class="computeroutput"><span class="identifier">print</span><span class="special">(</span><span class="identifier">age</span> <span class="special">=</span> <span class="number">3</span><span class="special">);</span></code> will assign
<code class="computeroutput"><span class="number">3</span></code> to <code class="computeroutput"><span class="identifier">f</span></code>'s
parameter <code class="computeroutput"><span class="identifier">age</span></code> instead than
passing <code class="computeroutput"><span class="number">3</span></code> as the argument of
<code class="computeroutput"><span class="identifier">print</span></code>'s parameter <code class="computeroutput"><span class="identifier">age</span></code>. The trailing underscore <code class="computeroutput"><span class="identifier">_</span></code> convention and enclosing the named parameter
declaration macros <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_TEMPLATE_PARAMETER" title="Macro CONTRACT_TEMPLATE_PARAMETER">CONTRACT_TEMPLATE_PARAMETER</a></code>
within a namespace make this type of name clashes unlikely.
</p></div></div><div class="section" title="Examples"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.examples"></a><a class="link" href="#contract__.examples" title="Examples">Examples</a></h2></div></div></div><p>
This section lists non-trivial examples programmed using this library. The
listed examples are taken from the foloowing sources (which are referenced
in the title of each example).
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
Sources
</p>
</th><th>
<p>
Notes
</p>
</th></tr></thead><tbody><tr><td>
<p>
<a class="link" href="#N1962_anchor">[N1962]</a>
</p>
</td><td>
<p>
Examples from the proposal to add Contract Programming to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a> submitted
to the standard committee (unfortunately, this proposal was never
accepted into the standard).
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#N2081_anchor">[N2081]</a>
</p>
</td><td>
<p>
Examples from the proposal to add concepts to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
submitted to the standard committee (unfortunately, this proposal
was never accepted into the standard). These examples have been extended
to specify both concepts and contracts.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Meyer97_anchor">[Meyer97]</a> <a class="link" href="#Mitchell02_anchor">[Mitchell02]</a>
</p>
</td><td>
<p>
Examples using the <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
programming language and reprogrammed using this library for C++.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Cline90_anchor">[Cline90]</a>
</p>
</td><td>
<p>
Examples from a very early proposal called Annotated C++ (A++) to
add Contract Programming to C++ (A++ was never implemented or proposed
for addition to the standard).
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#Stroustrup97_anchor">[Stroustrup97]</a>
</p>
</td><td>
<p>
One example that shows the importance of class invariants and how
to configure this library to throw exceptions instead of terminating
the program when contracts are broken.
</p>
</td></tr></tbody></table></div><p>
The followings are among the most interesting examples:
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
Key Example
</p>
</th><th>
<p>
Topic
</p>
</th></tr></thead><tbody><tr><td>
<p>
<a class="link" href="#contract__.examples.__n1962___vector__comparison_with_c___proposed_syntax" title="[N1962] Vector: Comparison with C++ proposed syntax">[N1962]
Vector</a>
</p>
</td><td>
<p>
A comparison between this library syntax and the syntax for contract
and concept checking proposed by <a class="link" href="#N1962_anchor">[N1962]</a>
and <a class="link" href="#N2081_anchor">[N2081]</a> respectively.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#contract__.examples.__n2081___add__generic_addition_algorithm" title="[N2081] Add: Generic addition algorithm">[N2081]
Add</a>
</p>
</td><td>
<p>
Contracts and user-defined concepts.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#contract__.examples.__mitchell02___counter__subcontracting_and_virtual_specifiers__final__override__new__and_pure_virtual_" title="[Mitchell02] Counter: Subcontracting and virtual specifiers (final, override, new, and pure virtual)">[Mitchell02]
Counter</a>
</p>
</td><td>
<p>
Subcontracting and <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>-like
virtual specifiers <code class="computeroutput"><span class="identifier">final</span></code>,
<code class="computeroutput"><span class="identifier">override</span></code>, <code class="computeroutput"><span class="keyword">new</span></code>, and pure virtual.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#contract__.examples.__meyer97___stack4__comparison_with_eiffel_syntax" title="[Meyer97] Stack4: Comparison with Eiffel syntax">[Meyer97]
Stack4</a>
</p>
</td><td>
<p>
A comparison between this library and <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
syntax for preconditions, postconditions, and class invariants.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#contract__.examples.__meyer97___gcd__loop_variants_and_invariants_plus_comparison_with_eiffel_syntax" title="[Meyer97] GCD: Loop variants and invariants plus comparison with Eiffel syntax">[Meyer97]
GCD</a>
</p>
</td><td>
<p>
A comparison between this library and <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
syntax for loop variants and block invariants.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#contract__.examples.__cline90___vector__comparison_with_a___proposed_syntax" title="[Cline90] Vector: Comparison with A++ proposed syntax">[Cline90]
Vector</a>
</p>
</td><td>
<p>
A comparison between this library and A++ syntax.
</p>
</td></tr></tbody></table></div><div class="section" title="[N1962] Vector: Comparison with C++ proposed syntax"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n1962___vector__comparison_with_c___proposed_syntax"></a><a class="link" href="#contract__.examples.__n1962___vector__comparison_with_c___proposed_syntax" title="[N1962] Vector: Comparison with C++ proposed syntax">[N1962]
Vector: Comparison with C++ proposed syntax</a></h3></div></div></div><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
This Library (C++03)
</p>
</th><th>
<p>
[N1962] and [N2081] Proposals (not part of C++)
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: vector.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">cxx11</span><span class="special">/</span><span class="identifier">all_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Vector wrapper with contracts.</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="comment">// No base classes so no subcontracting for this example.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="comment">// At very beginning of the class declaration.</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">()),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rbegin</span><span class="special">(),</span> <span class="identifier">rend</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">()),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">()</span>
<span class="special">)</span> <span class="comment">// No static or volatile class invariants for this example.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">allocator_type</span>
<span class="identifier">allocator_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">pointer</span> <span class="identifier">pointer</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_pointer</span>
<span class="identifier">const_pointer</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">reference</span> <span class="identifier">reference</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_reference</span>
<span class="identifier">const_reference</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">iterator</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span>
<span class="identifier">const_iterator</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">difference_type</span>
<span class="identifier">difference_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">reverse_iterator</span>
<span class="identifier">reverse_iterator</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_reverse_iterator</span>
<span class="identifier">const_reverse_iterator</span><span class="special">;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Always specify access level `public`, etc.</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// Member initializers.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;)</span> <span class="identifier">allocator</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">empty</span><span class="special">(),</span>
<span class="identifier">allocator</span> <span class="special">==</span> <span class="identifier">get_allocator</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">allocator</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">T</span><span class="special">()),</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="comment">// Requirements.</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span><span class="special">,</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">value</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</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="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span><span class="special">,</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;)</span> <span class="identifier">allocator</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">value</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">allocator</span> <span class="special">==</span> <span class="identifier">get_allocator</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">allocator</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Contract with concepts.</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;)</span> <span class="identifier">allocator</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">()),</span>
<span class="identifier">allocator</span> <span class="special">==</span> <span class="identifier">get_allocator</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">allocator</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">vector</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">right</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">vector_</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Operator symbol and (arbitrary) name `copy`.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(=)(</span><span class="identifier">copy</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">vector</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="comment">// Return value.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">vector_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Destruct contract (check class invariant).</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="comment">// Wrapping parenthesis optional for keyword types `void`, `bool`, etc.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">reserve</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="special">(</span><span class="identifier">capacity</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="comment">// Constant member.</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">begin</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">(</span> <span class="comment">// Select assertions `if(...) ( ...)`.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span>
<span class="special">)</span> <span class="comment">// Omitted optional `else( ... )`.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Contract overloaded function (see above).</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">begin</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">(</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Contract with no pre/post checks class invariants.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">end</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">end</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reverse_iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">rbegin</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">(</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">rend</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rbegin</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_reverse_iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">rbegin</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">(</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">rend</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rbegin</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reverse_iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">rend</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rend</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_reverse_iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">rend</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rend</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">resize</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span> <span class="comment">// Old value (at entry).</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">count</span> <span class="special">&gt;</span> <span class="identifier">old_size</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">old_size</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">T</span><span class="special">()),</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">resize</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span><span class="special">,</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">postcondition</span><span class="special">(</span>
<span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span> <span class="comment">// With old type.</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">count</span> <span class="special">&gt;</span> <span class="identifier">old_size</span> <span class="special">?</span> <span class="comment">// Ternary operator.</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">old_size</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">value</span><span class="special">)</span>
<span class="special">:</span>
<span class="keyword">true</span>
<span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span><span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="special">(</span><span class="identifier">size</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="special">(</span><span class="identifier">max_size</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">max_size</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</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="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">Allocator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">get_allocator</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">get_allocator</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="special">(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">index</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_reference</span><span class="special">)</span> <span class="special">(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">index</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">index</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_reference</span><span class="special">)</span> <span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">index</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="special">(</span><span class="identifier">front</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// `not` instead of symbol `!`.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">front</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_reference</span><span class="special">)</span> <span class="special">(</span><span class="identifier">front</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">bool</span><span class="special">(!</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">)</span> <span class="comment">// Or, `bool` to wrap symbol `!`.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">front</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">)</span> <span class="special">(</span><span class="identifier">back</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">const_reference</span><span class="special">)</span> <span class="special">(</span><span class="identifier">back</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</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="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</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="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">pop_back</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">-</span> <span class="number">1</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">pop_back</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">assign</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="comment">// precondition: [begin(), end()) does not contain [first, last)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">assign</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span><span class="special">,</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">value</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">insert</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">where</span><span class="special">,</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">result</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span>
<span class="comment">// if(capacity() &gt; oldof capacity())</span>
<span class="comment">// [begin(), end()) is invalid</span>
<span class="comment">// else</span>
<span class="comment">// [where, end()) is invalid</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">where</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">insert</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">where</span><span class="special">,</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">count</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">prior</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_where</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">where</span><span class="special">,</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_capacity</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">prior</span><span class="special">(</span><span class="identifier">old_where</span><span class="special">),</span>
<span class="identifier">prior</span><span class="special">(</span><span class="identifier">old_where</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="comment">// [where, end()) is invalid</span>
<span class="special">)</span> <span class="comment">// else [begin(), end()) is invalid</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">where</span><span class="special">,</span> <span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">insert</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">where</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="comment">// [first, last) is not contained in [begin(), end())</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">),</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">where</span><span class="special">,</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">erase</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">where</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">empty</span><span class="special">(),</span>
<span class="identifier">where</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">(</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span> <span class="special">)</span>
<span class="comment">// [where, end()) is invalid</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">erase</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">-</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">),</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">(</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span> <span class="special">)</span>
<span class="comment">// [first, last) is invalid</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">clear</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">clear</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">swap</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_self</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="special">*</span><span class="keyword">this</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_right</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">right</span><span class="special">,</span>
<span class="identifier">right</span> <span class="special">==</span> <span class="identifier">old_self</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">old_right</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">right</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">friend</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span> <span class="identifier">vector</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">left</span><span class="special">,</span> <span class="identifier">vector</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">vector_</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">vector_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span> <span class="identifier">vector_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// Run a few of the operations (could test more of them...).</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">v</span><span class="special">,</span> <span class="char">'\0'</span><span class="special">));</span>
<span class="keyword">const</span> <span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;&amp;</span> <span class="identifier">cv</span> <span class="special">=</span> <span class="identifier">v</span><span class="special">;</span> <span class="comment">// A reference so no copy.</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="identifier">w</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">w</span> <span class="special">==</span> <span class="identifier">v</span><span class="special">);</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(*</span><span class="identifier">b</span> <span class="special">==</span> <span class="char">'\0'</span><span class="special">);</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span> <span class="identifier">cb</span> <span class="special">=</span> <span class="identifier">cv</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(*</span><span class="identifier">cb</span> <span class="special">==</span> <span class="char">'\0'</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="number">2</span><span class="special">,</span> <span class="char">'a'</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="char">'a'</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="char">'a'</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="char">'b'</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="char">'b'</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: vector_npaper.cpp</span>
<span class="comment">// Extra spaces, newlines, etc used to align text with this library code.</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">cxx11</span><span class="special">/</span><span class="identifier">all_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">concepts</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">vector</span>
<span class="special">{</span>
<span class="identifier">invariant</span> <span class="special">{</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">());</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rbegin</span><span class="special">(),</span> <span class="identifier">rend</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">());</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">();</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">allocator_type</span>
<span class="identifier">allocator_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">pointer</span> <span class="identifier">pointer</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_pointer</span>
<span class="identifier">const_pointer</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">reference</span> <span class="identifier">reference</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_reference</span>
<span class="identifier">const_reference</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">iterator</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span>
<span class="identifier">const_iterator</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">difference_type</span>
<span class="identifier">difference_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">reverse_iterator</span>
<span class="identifier">reverse_iterator</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span><span class="identifier">const_reverse_iterator</span>
<span class="identifier">const_reverse_iterator</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">vector</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">()</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">vector</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">alllocator</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">empty</span><span class="special">();</span>
<span class="identifier">allocator</span> <span class="special">==</span> <span class="identifier">get_allocator</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">allocator</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">vector</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">T</span><span class="special">());</span>
<span class="comment">// Assertion requirements not supported by [N1962].</span>
<span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">vector</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">vector</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">allocator</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">value</span><span class="special">);</span>
<span class="identifier">allocator</span> <span class="special">==</span> <span class="identifier">get_allocator</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">,</span> <span class="identifier">allocator</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">&gt;</span>
<span class="identifier">requires</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="identifier">vector</span> <span class="special">(</span> <span class="identifier">Iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iterator</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">());</span> <span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">&gt;</span>
<span class="identifier">requires</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="identifier">vector</span> <span class="special">(</span> <span class="identifier">Iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iterator</span> <span class="identifier">last</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&amp;</span> <span class="identifier">allocator</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">());</span>
<span class="identifier">allocator</span> <span class="special">==</span> <span class="identifier">get_allocator</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">allocator</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">vector</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">vector</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">right</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">:</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">vector_</span><span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">vector</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">vector</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">right</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vect_</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">vect_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">vector</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">reserve</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">count</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">postcondition</span> <span class="special">{</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">count</span><span class="special">;</span> <span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">size_type</span> <span class="identifier">capacity</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">iterator</span> <span class="identifier">begin</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_iterator</span> <span class="identifier">begin</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">();</span> <span class="special">}</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">iterator</span> <span class="identifier">end</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_iterator</span> <span class="identifier">end</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">reverse_iterator</span> <span class="identifier">rbegin</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">rend</span><span class="special">();</span> <span class="special">}</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rbegin</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reverse_iterator</span> <span class="identifier">rbegin</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">rend</span><span class="special">();</span> <span class="special">}</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rbegin</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">reverse_iterator</span> <span class="identifier">rend</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rend</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reverse_iterator</span> <span class="identifier">rend</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">rend</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">resize</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">count</span> <span class="special">&gt;</span> <span class="identifier">oldof</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">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">T</span><span class="special">());</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vectcor_</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">resize</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span><span class="special">,</span> <span class="identifier">T</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">;</span>
<span class="identifier">count</span> <span class="special">&gt;</span> <span class="identifier">oldof</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">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">value</span><span class="special">)</span>
<span class="special">:</span>
<span class="keyword">true</span>
<span class="special">;</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span><span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">size_type</span> <span class="identifier">size</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">size_type</span> <span class="identifier">max_size</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="identifier">capacity</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">max_size</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">bool</span> <span class="identifier">empty</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">Alloctor</span> <span class="identifier">get_allocator</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">get_allocator</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">reference</span> <span class="identifier">at</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vectcor_</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">index</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reference</span> <span class="identifier">at</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">index</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">index</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">reference</span> <span class="keyword">operator</span><span class="special">[]</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reference</span> <span class="keyword">operator</span><span class="special">[]</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">index</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vectcor_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">reference</span> <span class="identifier">front</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vectcor_</span><span class="special">.</span><span class="identifier">front</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reference</span> <span class="identifier">front</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="keyword">bool</span><span class="special">(!</span><span class="identifier">empty</span><span class="special">());</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">front</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">reference</span> <span class="identifier">back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">const_reference</span> <span class="identifier">back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="identifier">push_back</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">}</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">back</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">vallue</span><span class="special">;</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="number">1</span><span class="special">;</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">oldof</span> <span class="identifier">capacity</span><span class="special">()</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</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="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">pop_back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">-</span> <span class="number">1</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">pop_back</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">&gt;</span>
<span class="identifier">requires</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">assign</span> <span class="special">(</span> <span class="identifier">Iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iterator</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="comment">// precondition: [begin(), end()) does not contain [first, last)</span>
<span class="identifier">postcondition</span> <span class="special">{</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">());</span> <span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">assign</span> <span class="special">(</span> <span class="identifier">size_type</span> <span class="identifier">count</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">vallue</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">count</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">assign</span><span class="special">(</span><span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">iterator</span> <span class="identifier">insert</span> <span class="special">(</span> <span class="identifier">iterator</span> <span class="identifier">where</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">result</span><span class="special">;</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="number">1</span><span class="special">;</span>
<span class="comment">// if(capacity() &gt; oldof capacity())</span>
<span class="comment">// [begin(), end()) is invalid</span>
<span class="comment">// else</span>
<span class="comment">// [where, end()) is invalid</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">where</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">insert</span> <span class="special">(</span> <span class="identifier">iterator</span> <span class="identifier">where</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">count</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">count</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">();</span> <span class="special">}</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">count</span><span class="special">;</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">oldof</span> <span class="identifier">capacity</span><span class="special">();</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="identifier">capacity</span><span class="special">())</span> <span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">prior</span><span class="special">(</span><span class="identifier">oldof</span> <span class="identifier">where</span><span class="special">),</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">prior</span><span class="special">(</span><span class="identifier">oldof</span> <span class="identifier">where</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="comment">// [where, end()) is invalid</span>
<span class="special">}</span> <span class="comment">// else [begin(), end()) is invalid</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">where</span><span class="special">,</span> <span class="identifier">count</span><span class="special">,</span> <span class="identifier">value</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Iterator</span> <span class="special">&gt;</span>
<span class="identifier">requires</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">insert</span> <span class="special">(</span> <span class="identifier">iterator</span> <span class="identifier">where</span><span class="special">,</span> <span class="identifier">Iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iterator</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span>
<span class="comment">// [first, last) is not contained in [begin(), end())</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">oldof</span> <span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">where</span><span class="special">,</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">iterator</span> <span class="identifier">erase</span> <span class="special">(</span> <span class="identifier">iterator</span> <span class="identifier">where</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span>
<span class="keyword">not</span> <span class="identifier">empty</span><span class="special">();</span>
<span class="identifier">where</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</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">oldod</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">-</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">();</span> <span class="special">}</span>
<span class="comment">// [where, end()) is invalid</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">iterator</span> <span class="identifier">erase</span> <span class="special">(</span> <span class="identifier">iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">last</span> <span class="special">)</span>
<span class="identifier">precondition</span> <span class="special">{</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">lasst</span><span class="special">);</span> <span class="special">}</span>
<span class="identifier">postcondition</span><span class="special">(</span><span class="identifier">result</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">oldof</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">-</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">();</span> <span class="special">}</span>
<span class="comment">// [first, last) is invalid</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">clear</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">clear</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">swap</span> <span class="special">(</span> <span class="identifier">vector</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span> <span class="special">{</span>
<span class="identifier">right</span> <span class="special">==</span> <span class="identifier">oldof</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="identifier">oldof</span> <span class="identifier">right</span> <span class="special">==</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">{</span>
<span class="identifier">vector_</span><span class="special">.</span><span class="identifier">swap</span><span class="special">(</span><span class="identifier">right</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">friend</span> <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">==</span> <span class="special">(</span> <span class="identifier">vector</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">left</span><span class="special">,</span> <span class="identifier">vector</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">vector_</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">vector_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span> <span class="identifier">vector_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p>
</td></tr></tbody></table></div></div><div class="section" title="[N1962] Circle: Subcontracting"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n1962___circle__subcontracting"></a><a class="link" href="#contract__.examples.__n1962___circle__subcontracting" title="[N1962] Circle: Subcontracting">[N1962]
Circle: Subcontracting</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: circle.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">shape</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// Must always specify class invariants.</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">shape</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">compute_area</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="comment">// No base preconditions so all derived preconditions true.</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Contract for pure virtual function.</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">circle</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">shape</span> <span class="special">)</span> <span class="comment">// Subcontract from base `shape`.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// In AND with base class invariants.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">radius</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="number">2</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Also using `override` specifier (optional).</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">compute_area</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="identifier">override</span>
<span class="comment">// Eventual preconditions in OR with base function preconditions.</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="comment">// In AND with base function postconditions.</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">pi</span> <span class="special">*</span> <span class="identifier">radius</span><span class="special">()</span> <span class="special">*</span> <span class="identifier">radius</span><span class="special">()</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">pi</span> <span class="special">*</span> <span class="identifier">radius</span><span class="special">()</span> <span class="special">*</span> <span class="identifier">radius</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span> <span class="comment">// Truncated from 3.14...</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">circle</span> <span class="identifier">c</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">compute_area</span><span class="special">()</span> <span class="special">==</span> <span class="number">12</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N1962] Factorial: Recursion and assertion computational complexity"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n1962___factorial__recursion_and_assertion_computational_complexity"></a><a class="link" href="#contract__.examples.__n1962___factorial__recursion_and_assertion_computational_complexity" title="[N1962] Factorial: Recursion and assertion computational complexity">[N1962]
Factorial: Recursion and assertion computational complexity</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: factorial.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">// Assertion requirements used to model assertion computational complexity.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_1</span> <span class="number">0</span> <span class="comment">// O(1) constant (default).</span>
<span class="preprocessor">#define</span> <span class="identifier">O_N</span> <span class="number">1</span> <span class="comment">// O(n) linear.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_NN</span> <span class="number">2</span> <span class="comment">// O(n * n) quadratic.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_NX</span> <span class="number">3</span> <span class="comment">// O(n^x) polynomial.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_FACTN</span> <span class="number">4</span> <span class="comment">// O(n!) factorial.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_EXPN</span> <span class="number">5</span> <span class="comment">// O(e^n) exponential.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_ALL</span> <span class="number">10</span>
<span class="preprocessor">#define</span> <span class="identifier">COMPLEXITY_MAX</span> <span class="identifier">O_ALL</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="special">(</span><span class="identifier">factorial</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">n</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">,</span> <span class="comment">// Non-negative natural number.</span>
<span class="identifier">n</span> <span class="special">&lt;=</span> <span class="number">12</span> <span class="comment">// Max function input.</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">1</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">n</span> <span class="special">&lt;</span> <span class="number">2</span><span class="special">)</span> <span class="special">(</span> <span class="comment">// Select assertion.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="number">1</span>
<span class="special">)</span> <span class="keyword">else</span> <span class="special">(</span>
<span class="comment">// Assertions automatically disabled within other assertions.</span>
<span class="comment">// Therefore, this postcondition can recursively call the</span>
<span class="comment">// function without causing infinite recursion.</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">),</span>
<span class="comment">// This assertion introduces significant run-time</span>
<span class="comment">// overhead (same as the function body) so assertion</span>
<span class="comment">// requirements are used to selectively disable it.</span>
<span class="identifier">requires</span> <span class="identifier">O_FACTN</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span>
<span class="special">)</span>
<span class="special">)</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">&lt;</span> <span class="number">2</span><span class="special">)</span> <span class="keyword">return</span> <span class="number">1</span><span class="special">;</span>
<span class="keyword">else</span> <span class="keyword">return</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">factorial</span><span class="special">(</span><span class="number">4</span><span class="special">)</span> <span class="special">==</span> <span class="number">24</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N1962] Equal: Operators"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n1962___equal__operators"></a><a class="link" href="#contract__.examples.__n1962___equal__operators" title="[N1962] Equal: Operators">[N1962]
Equal: Operators</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: equal.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">EQUAL_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">EQUAL_HPP_</span>
<span class="preprocessor">#include</span> <span class="string">"equal_not.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<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">bool</span> <span class="keyword">operator</span><span class="special">(==)(</span><span class="identifier">equal</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">!(</span><span class="identifier">left</span> <span class="special">!=</span> <span class="identifier">right</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">value</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: equal_not.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">EQUAL_NOT_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">EQUAL_NOT_HPP_</span>
<span class="preprocessor">#include</span> <span class="string">"equal.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<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">bool</span> <span class="keyword">operator</span><span class="special">(!=)(</span><span class="identifier">not_equal</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">!(</span><span class="identifier">left</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">value</span> <span class="special">!=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: equal_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"equal.hpp"</span>
<span class="preprocessor">#include</span> <span class="string">"equal_not.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">number</span> <span class="special">{</span> <span class="keyword">int</span> <span class="identifier">value</span><span class="special">;</span> <span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">number</span> <span class="identifier">n</span><span class="special">;</span>
<span class="identifier">n</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">123</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">((</span><span class="identifier">n</span> <span class="special">==</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">true</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">((</span><span class="identifier">n</span> <span class="special">!=</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N1962] Sum: Separated body definitions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n1962___sum__separated_body_definitions"></a><a class="link" href="#contract__.examples.__n1962___sum__separated_body_definitions" title="[N1962] Sum: Separated body definitions">[N1962]
Sum: Separated body definitions</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: sum.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">SUM_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">SUM_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="special">(</span><span class="identifier">sum</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="keyword">int</span><span class="special">*)</span> <span class="identifier">array</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">%</span> <span class="number">4</span> <span class="special">==</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Separate body definition from function declaration (see ".cpp" file).</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: sum.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"sum.hpp"</span>
<span class="keyword">int</span> <span class="identifier">CONTRACT_FREE_BODY</span><span class="special">(</span><span class="identifier">sum</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">count</span><span class="special">,</span> <span class="keyword">int</span><span class="special">*</span> <span class="identifier">array</span> <span class="special">)</span> <span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">total</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">count</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">total</span> <span class="special">+=</span> <span class="identifier">array</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="keyword">return</span> <span class="identifier">total</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: sum_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"sum.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">a</span><span class="special">[</span><span class="number">8</span><span class="special">]</span> <span class="special">=</span> <span class="special">{</span><span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">};</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">sum</span><span class="special">(</span><span class="number">8</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span> <span class="special">==</span> <span class="number">8</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N1962] Square Root: Default parameters and comparison with D syntax"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n1962___square_root__default_parameters_and_comparison_with_d_syntax"></a><a class="link" href="#contract__.examples.__n1962___square_root__default_parameters_and_comparison_with_d_syntax" title="[N1962] Square Root: Default parameters and comparison with D syntax">[N1962]
Square Root: Default parameters and comparison with D syntax</a></h3></div></div></div><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
This Library (C++03)
</p>
</th><th>
<p>
The D Programming Language
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: sqrt.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cmath</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Default value for `precision` parameter.</span>
<span class="keyword">double</span> <span class="special">(</span><span class="identifier">mysqrt</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">double</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">precision</span><span class="special">,</span> <span class="keyword">default</span><span class="special">(</span><span class="number">1e-6</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">&gt;=</span> <span class="number">0.0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">root</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="comment">// Result value named `root`.</span>
<span class="identifier">fabs</span><span class="special">(</span><span class="identifier">root</span> <span class="special">*</span> <span class="identifier">root</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="identifier">precision</span> <span class="comment">// Equal within precision.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">fabs</span><span class="special">(</span><span class="identifier">mysqrt</span><span class="special">(</span><span class="number">4.0</span><span class="special">)</span> <span class="special">-</span> <span class="number">2.0</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="number">1e-6</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: sqrt.d</span>
<span class="comment">// Extra spaces, newlines, etc used to align text with this library code.</span>
<span class="identifier">real</span> <span class="identifier">mysqrt</span> <span class="special">(</span> <span class="identifier">real</span> <span class="identifier">x</span> <span class="special">)</span> <span class="comment">// No default parameters in D.</span>
<span class="identifier">in</span> <span class="special">{</span> <span class="identifier">assert</span><span class="special">(</span><span class="identifier">x</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">);</span> <span class="special">}</span>
<span class="identifier">out</span><span class="special">(</span><span class="identifier">root</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">.</span><span class="identifier">math</span><span class="special">.</span><span class="identifier">fabs</span><span class="special">(</span><span class="identifier">root</span> <span class="special">*</span> <span class="identifier">root</span> <span class="special">-</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="number">1e6</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">body</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">std</span><span class="special">.</span><span class="identifier">math</span><span class="special">.</span><span class="identifier">sqrt</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
</p>
</td></tr></tbody></table></div></div><div class="section" title="[N1962] Block: Block invariants"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n1962___block__block_invariants"></a><a class="link" href="#contract__.examples.__n1962___block__block_invariants" title="[N1962] Block: Block invariants">[N1962]
Block: Block invariants</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: block_invariant.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">for</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">i</span> <span class="special">&lt;</span> <span class="number">100</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">CONTRACT_BLOCK_INVARIANT</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">i</span> <span class="special">)</span> <span class="identifier">i</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">}</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">i</span> <span class="special">==</span> <span class="number">100</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Add: Generic addition algorithm"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___add__generic_addition_algorithm"></a><a class="link" href="#contract__.examples.__n2081___add__generic_addition_algorithm" title="[N2081] Add: Generic addition algorithm">[N2081]
Add: Generic addition algorithm</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: add.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">ADD_HPP</span>
<span class="preprocessor">#define</span> <span class="identifier">ADD_HPP</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">Addable</span> <span class="comment">// User-defined concept.</span>
<span class="special">{</span>
<span class="identifier">BOOST_CONCEPT_USAGE</span><span class="special">(</span><span class="identifier">Addable</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">return_type</span><span class="special">(</span><span class="identifier">x</span> <span class="special">+</span> <span class="identifier">y</span><span class="special">);</span> <span class="comment">// Check addition `T operator+(T x, T y)`.</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span>
<span class="keyword">void</span> <span class="identifier">return_type</span> <span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">)</span> <span class="special">{}</span> <span class="comment">// Used to check addition returns type `T`.</span>
<span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">;</span>
<span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="identifier">requires</span><span class="special">(</span> <span class="identifier">Addable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">add</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">x</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">y</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">y</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: add.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"add.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">10</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">add</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">==</span> <span class="number">30</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: add_error.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"add.hpp"</span>
<span class="keyword">struct</span> <span class="identifier">num</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">value</span><span class="special">;</span>
<span class="identifier">num</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">0</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">value</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">{};</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">num</span> <span class="identifier">n</span><span class="special">(</span><span class="number">10</span><span class="special">),</span> <span class="identifier">m</span><span class="special">(</span><span class="number">20</span><span class="special">);</span>
<span class="identifier">add</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span> <span class="identifier">m</span><span class="special">);</span> <span class="comment">// Error: Correctly fails `add` concept requirements.</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Advance: Concept-based iterator overloading (emulated using tags)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___advance__concept_based_iterator_overloading__emulated_using_tags_"></a><a class="link" href="#contract__.examples.__n2081___advance__concept_based_iterator_overloading__emulated_using_tags_" title="[N2081] Advance: Concept-based iterator overloading (emulated using tags)">[N2081]
Advance: Concept-based iterator overloading (emulated using tags)</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: advance.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">mpl</span><span class="special">/</span><span class="keyword">bool</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">list</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>
<span class="keyword">namespace</span> <span class="identifier">aux</span> <span class="special">{</span> <span class="comment">// Tag dispatch helpers (in a private namespace).</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Distance</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">myadvance_dispatch</span> <span class="special">(</span> <span class="identifier">InputIterator</span><span class="special">&amp;</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">Distance</span> <span class="identifier">n</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">input_iterator_tag</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">CONTRACT_LOOP</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="special">{</span>
<span class="identifier">CONTRACT_LOOP_VARIANT_TPL</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">n</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="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Distance</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">myadvance_dispatch</span> <span class="special">(</span> <span class="identifier">BidirectionalIterator</span><span class="special">&amp;</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">Distance</span> <span class="identifier">n</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">bidirectional_iterator_tag</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">&gt;=</span> <span class="number">0</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_LOOP</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="special">{</span>
<span class="identifier">CONTRACT_LOOP_VARIANT_TPL</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">n</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="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">CONTRACT_CONFIG_NO_LOOP_VARIANTS</span>
<span class="comment">// Avoid unused variable warning when loop invariants are disabled.</span>
<span class="identifier">Distance</span> <span class="identifier">n_max</span> <span class="special">=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="preprocessor">#endif</span>
<span class="identifier">CONTRACT_LOOP</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="special">{</span>
<span class="identifier">CONTRACT_LOOP_VARIANT_TPL</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">n_max</span><span class="special">,</span> <span class="identifier">n</span> <span class="special">)</span> <span class="identifier">n_max</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="special">}</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">RandomAccessIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Distance</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">myadvance_dispatch</span> <span class="special">(</span> <span class="identifier">RandomAccessIterator</span><span class="special">&amp;</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">Distance</span> <span class="identifier">n</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">random_access_iterator_tag</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="special">}</span> <span class="comment">// namespace aux</span>
<span class="comment">// Contract helper meta-function.</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_input_iterator</span> <span class="special">:</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span> <span class="special">{};</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">is_input_iterator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">input_iterator_tag</span><span class="special">&gt;</span> <span class="special">:</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span> <span class="special">{};</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Distance</span> <span class="special">)</span>
<span class="keyword">void</span> <span class="special">(</span><span class="identifier">myadvance</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">InputIterator</span><span class="special">&amp;)</span> <span class="identifier">i</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Distance</span><span class="special">)</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="comment">// range [i, i + n] is non-singular.</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">is_input_iterator</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span>
<span class="identifier">iterator_category</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">n</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="comment">// if input iterator, n positive</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_i</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">i</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">old_i</span><span class="special">,</span> <span class="identifier">i</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">n</span> <span class="comment">// iterator advanced of n</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">aux</span><span class="special">::</span><span class="identifier">myadvance_dispatch</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="keyword">typename</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">InputIterator</span><span class="special">&gt;::</span> <span class="identifier">iterator_category</span><span class="special">());</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">10</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="number">123</span><span class="special">;</span> <span class="identifier">v</span><span class="special">[</span><span class="number">3</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="number">123</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">r</span> <span class="special">=</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="comment">// Random iterator.</span>
<span class="identifier">myadvance</span><span class="special">(</span><span class="identifier">r</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(*</span><span class="identifier">r</span> <span class="special">==</span> <span class="special">-</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">l</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">b</span> <span class="special">=</span> <span class="identifier">l</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="comment">// Bidirectional and not random.</span>
<span class="identifier">myadvance</span><span class="special">(</span><span class="identifier">b</span><span class="special">,</span> <span class="number">2</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(*</span><span class="identifier">b</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Find: Generic find algorithm"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___find__generic_find_algorithm"></a><a class="link" href="#contract__.examples.__n2081___find__generic_find_algorithm" title="[N2081] Find: Generic find algorithm">[N2081]
Find: Generic find algorithm</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: find.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">FIND_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">FIND_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">EqualityComparable</span><span class="special">&lt;</span> <span class="comment">// Equality needed to find value.</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;</span>
<span class="special">)</span>
<span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">myfind</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="comment">// precondition: range [first, last) is valid</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">result</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">value</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">result</span> <span class="comment">// if result not last, value found</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span> <span class="special">&amp;&amp;</span> <span class="special">*</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">value</span><span class="special">)</span> <span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_LOOP_VARIANT_TPL</span><span class="special">(</span>
<span class="keyword">const</span><span class="special">(</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span> <span class="special">)</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span>
<span class="special">++</span><span class="identifier">first</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="identifier">first</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: find.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"find.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">ints</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">ints</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">ints</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span> <span class="identifier">ints</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(*</span><span class="identifier">myfind</span><span class="special">(</span><span class="identifier">ints</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">ints</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="number">2</span><span class="special">)</span> <span class="special">==</span> <span class="number">2</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: find_error.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"find.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">num</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">value</span><span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">num</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">0</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">value</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">num</span><span class="special">&gt;</span> <span class="identifier">nums</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">nums</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">num</span><span class="special">(</span><span class="number">1</span><span class="special">);</span> <span class="identifier">nums</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">num</span><span class="special">(</span><span class="number">2</span><span class="special">);</span> <span class="identifier">nums</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">num</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="comment">// Error: Correctly, num does not meet concept requirements.</span>
<span class="identifier">myfind</span><span class="special">(</span><span class="identifier">nums</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">nums</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">num</span><span class="special">(</span><span class="number">2</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Apply: Overloaded invocation of functors"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___apply__overloaded_invocation_of_functors"></a><a class="link" href="#contract__.examples.__n2081___apply__overloaded_invocation_of_functors" title="[N2081] Apply: Overloaded invocation of functors">[N2081]
Apply: Overloaded invocation of functors</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: apply.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">// Use assertion requirements to model assertion computational complexity.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_1</span> <span class="number">0</span> <span class="comment">// constant computational complexity O(1)</span>
<span class="preprocessor">#define</span> <span class="identifier">O_BODY</span> <span class="number">10</span> <span class="comment">// same computation complexity of the body</span>
<span class="preprocessor">#define</span> <span class="identifier">COMPLEXITY_MAX</span> <span class="identifier">O_1</span> <span class="comment">// only check assertions with complexity within O(1)</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Invoke unary functors.</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Result</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Argument0</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Function</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">UnaryFunction</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">,</span> <span class="identifier">Result</span><span class="special">,</span> <span class="identifier">Argument0</span><span class="special">&gt;)</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">Result</span><span class="special">)</span> <span class="special">(</span><span class="identifier">apply</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Function</span><span class="special">)</span> <span class="identifier">function</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Argument0</span><span class="special">)</span> <span class="identifier">argument0</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">Result</span><span class="special">&amp;)</span> <span class="identifier">result</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">return_value</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">function</span><span class="special">(</span><span class="identifier">argument0</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">O_BODY</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span> <span class="special">&amp;&amp;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">Result</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">return_value</span> <span class="special">==</span> <span class="identifier">result</span><span class="special">,</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">Result</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">function</span><span class="special">(</span><span class="identifier">argument0</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Overload to invoke binary functors.</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Result</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Argument0</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Argument1</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">Function</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">BinaryFunction</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">,</span> <span class="identifier">Result</span><span class="special">,</span> <span class="identifier">Argument0</span><span class="special">,</span>
<span class="identifier">Argument1</span><span class="special">&gt;)</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">Result</span><span class="special">)</span> <span class="special">(</span><span class="identifier">apply</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Function</span><span class="special">)</span> <span class="identifier">function</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Argument0</span><span class="special">)</span> <span class="identifier">argument0</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">Argument1</span><span class="special">)</span> <span class="identifier">argument1</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Result</span><span class="special">&amp;)</span> <span class="identifier">result</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">return_value</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">function</span><span class="special">(</span><span class="identifier">argument0</span><span class="special">,</span> <span class="identifier">argument1</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">O_BODY</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span> <span class="special">&amp;&amp;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">Result</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span>
<span class="identifier">return_value</span> <span class="special">==</span> <span class="identifier">result</span><span class="special">,</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">Result</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">function</span><span class="special">(</span><span class="identifier">argument0</span><span class="special">,</span> <span class="identifier">argument1</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">complement</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">return</span> <span class="special">-</span><span class="identifier">x</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">add</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">y</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">r</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">apply</span><span class="special">(</span><span class="identifier">complement</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">r</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">r</span> <span class="special">==</span> <span class="special">-</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">apply</span><span class="special">(</span><span class="identifier">add</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">,</span> <span class="identifier">r</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">r</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] For Each: Generic for-each algorithm"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___for_each__generic_for_each_algorithm"></a><a class="link" href="#contract__.examples.__n2081___for_each__generic_for_each_algorithm" title="[N2081] For Each: Generic for-each algorithm">[N2081]
For Each: Generic for-each algorithm</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: for_each.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Iterator</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Function</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;,</span>
<span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">UnaryFunction</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">,</span> <span class="keyword">void</span><span class="special">,</span> <span class="keyword">typename</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;)</span>
<span class="special">)</span>
<span class="special">(</span><span class="identifier">Function</span><span class="special">)</span> <span class="special">(</span><span class="identifier">my_for_each</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">Function</span><span class="special">)</span> <span class="identifier">function</span> <span class="special">)</span>
<span class="comment">// precondition: range [first, last) is valid</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">function</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">&lt;</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">// OK: Iterator is InputIterator.</span>
<span class="identifier">CONTRACT_LOOP_VARIANT_TPL</span><span class="special">(</span>
<span class="keyword">const</span><span class="special">(</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span> <span class="special">)</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">function</span><span class="special">(*</span><span class="identifier">first</span><span class="special">);</span> <span class="comment">// OK: Function is UnaryFunction.</span>
<span class="special">++</span><span class="identifier">first</span><span class="special">;</span> <span class="comment">// OK: Iterator is InputIterator.</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="identifier">function</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">total</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="keyword">void</span> <span class="identifier">add</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">)</span> <span class="special">{</span> <span class="identifier">total</span> <span class="special">+=</span> <span class="identifier">i</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">v</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span> <span class="identifier">v</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
<span class="identifier">my_for_each</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">add</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">total</span> <span class="special">==</span> <span class="number">6</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Transform: Generic binary transformation algorithm"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___transform__generic_binary_transformation_algorithm"></a><a class="link" href="#contract__.examples.__n2081___transform__generic_binary_transformation_algorithm" title="[N2081] Transform: Generic binary transformation algorithm">[N2081]
Transform: Generic binary transformation algorithm</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: transform.cpp</span>
<span class="preprocessor">#define</span> <span class="identifier">CONTRACT_CONFIG_FUNCTION_ARITY_MAX</span> <span class="number">5</span> <span class="comment">// Support for 5 parameters.</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">Iterator1</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">Iterator2</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">ResultIterator</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">Function</span>
<span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator1</span><span class="special">&gt;,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator2</span><span class="special">&gt;,</span>
<span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">OutputIterator</span><span class="special">&lt;</span><span class="identifier">ResultIterator</span><span class="special">,</span> <span class="keyword">typename</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator1</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;),</span>
<span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">BinaryFunction</span><span class="special">&lt;</span><span class="identifier">Function</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator1</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator1</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator2</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;)</span>
<span class="special">)</span>
<span class="special">(</span><span class="identifier">ResultIterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">mytransform</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">Iterator1</span><span class="special">)</span> <span class="identifier">first1</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">Iterator1</span><span class="special">)</span> <span class="identifier">last1</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">Iterator2</span><span class="special">)</span> <span class="identifier">first2</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">ResultIterator</span><span class="special">)</span> <span class="identifier">result</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">Function</span><span class="special">)</span> <span class="identifier">function</span>
<span class="special">)</span>
<span class="comment">// precondition: [first1, last1) is valid</span>
<span class="comment">// precondition: [first2, first2 + (last1 - first1)) is valid</span>
<span class="comment">// precondition: result is not an iterator within [first1 + 1, last1)</span>
<span class="comment">// or [first2 + 1, first2 + (last1 - first1))</span>
<span class="comment">// precondition: [result, result + (last1 - first1)) is valid</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">transform</span><span class="special">(</span><span class="identifier">first1</span><span class="special">,</span> <span class="identifier">last1</span><span class="special">,</span> <span class="identifier">first2</span><span class="special">,</span> <span class="identifier">result</span><span class="special">,</span> <span class="identifier">function</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span> <span class="identifier">v</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span> <span class="identifier">v</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">w</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">w</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">10</span><span class="special">;</span> <span class="identifier">w</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">20</span><span class="special">;</span> <span class="identifier">w</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="number">30</span><span class="special">;</span>
<span class="identifier">mytransform</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">w</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">plus</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;());</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">11</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="number">22</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">==</span> <span class="number">33</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Count: Generic counting algorithm"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___count__generic_counting_algorithm"></a><a class="link" href="#contract__.examples.__n2081___count__generic_counting_algorithm" title="[N2081] Count: Generic counting algorithm">[N2081]
Count: Generic counting algorithm</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: count.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">EqualityComparable</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">EqualityComparable</span><span class="special">&lt;</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;</span>
<span class="special">)</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">difference_type</span><span class="special">)</span> <span class="special">(</span><span class="identifier">mycount</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">first</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">last</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="comment">// precondition: range [first, last) is valid</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">difference_type</span> <span class="identifier">result</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">// OK: Iterator has `==`.</span>
<span class="identifier">CONTRACT_LOOP_VARIANT_TPL</span><span class="special">(</span>
<span class="keyword">const</span><span class="special">(</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span> <span class="special">)</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span> <span class="special">)</span>
<span class="keyword">if</span><span class="special">(*</span><span class="identifier">first</span> <span class="special">==</span> <span class="identifier">value</span><span class="special">)</span> <span class="comment">// OK: Value is equality comparable.</span>
<span class="special">++</span><span class="identifier">result</span><span class="special">;</span>
<span class="special">++</span><span class="identifier">first</span><span class="special">;</span> <span class="comment">// OK: Iterator is input iterator.</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="identifier">result</span><span class="special">;</span> <span class="comment">// OK: Input iterator difference is copy constructible.</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="number">1</span><span class="special">;</span> <span class="identifier">v</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">v</span><span class="special">[</span><span class="number">2</span><span class="special">]</span> <span class="special">=</span> <span class="special">-</span><span class="number">1</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">mycount</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="special">-</span><span class="number">1</span><span class="special">)</span> <span class="special">==</span> <span class="number">2</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Convert: Conversion between two types"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___convert__conversion_between_two_types"></a><a class="link" href="#contract__.examples.__n2081___convert__conversion_between_two_types" title="[N2081] Convert: Conversion between two types">[N2081]
Convert: Conversion between two types</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: convert.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">CONVERT_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">CONVERT_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">To</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">From</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">From</span><span class="special">,</span> <span class="identifier">To</span><span class="special">&gt;)</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">To</span><span class="special">)</span> <span class="special">(</span><span class="identifier">convert</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">From</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">from</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">from</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: convert.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"convert.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">convert</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="char">'\0'</span><span class="special">)</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: convert_error.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"convert.hpp"</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">convert</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;(</span><span class="number">10</span><span class="special">);</span> <span class="comment">// Error: Correctly cannot convert type.</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Equal: Generic equality comparison"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___equal__generic_equality_comparison"></a><a class="link" href="#contract__.examples.__n2081___equal__generic_equality_comparison" title="[N2081] Equal: Generic equality comparison">[N2081]
Equal: Generic equality comparison</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: equal.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">EQUAL_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">EQUAL_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">EqualityComparable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="keyword">bool</span> <span class="special">(</span><span class="identifier">equal</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">left</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: equal.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"equal.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">equal</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">1</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">true</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">equal</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: equal_error.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"equal.hpp"</span>
<span class="keyword">struct</span> <span class="identifier">num</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">value</span><span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">num</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">0</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">value</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">equal</span><span class="special">(</span><span class="identifier">num</span><span class="special">(</span><span class="number">1</span><span class="special">),</span> <span class="identifier">num</span><span class="special">(</span><span class="number">1</span><span class="special">));</span> <span class="comment">// Compiler error.</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Less Equal: Generic less-than or equal-to comparison"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___less_equal__generic_less_than_or_equal_to_comparison"></a><a class="link" href="#contract__.examples.__n2081___less_equal__generic_less_than_or_equal_to_comparison" title="[N2081] Less Equal: Generic less-than or equal-to comparison">[N2081]
Less Equal: Generic less-than or equal-to comparison</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: less_eq.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">EqualityComparable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">LessThanComparable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
<span class="special">)</span>
<span class="keyword">bool</span> <span class="special">(</span><span class="identifier">less_eq</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="identifier">left</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">left</span> <span class="special">&lt;</span> <span class="identifier">right</span> <span class="special">||</span> <span class="identifier">left</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">left</span> <span class="special">&lt;</span> <span class="identifier">right</span> <span class="special">||</span> <span class="identifier">left</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">less_eq</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">true</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">less_eq</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">1</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] De-Ref: Generic iterator dereferencing"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___de_ref__generic_iterator_dereferencing"></a><a class="link" href="#contract__.examples.__n2081___de_ref__generic_iterator_dereferencing" title="[N2081] De-Ref: Generic iterator dereferencing">[N2081]
De-Ref: Generic iterator dereferencing</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: deref.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Iterator</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">CopyConstructible</span><span class="special">&lt;</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;</span>
<span class="special">)</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">)</span> <span class="special">(</span><span class="identifier">deref</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">Iterator</span><span class="special">)</span> <span class="identifier">iterator</span> <span class="special">)</span>
<span class="comment">// precondition: iterator is non-singular</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">*</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span>
<span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">InputIterator</span><span class="special">&lt;</span><span class="identifier">Iterator</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="special">*</span><span class="identifier">iterator</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">123</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">deref</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">begin</span><span class="special">())</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[N2081] Min: Generic minimum algorithm"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__n2081___min__generic_minimum_algorithm"></a><a class="link" href="#contract__.examples.__n2081___min__generic_minimum_algorithm" title="[N2081] Min: Generic minimum algorithm">[N2081]
Min: Generic minimum algorithm</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: min.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">MIN_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">MIN_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">concept_check</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<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="identifier">requires</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">LessThanComparable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">min</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">x</span><span class="special">,</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">y</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">x</span> <span class="special">&lt;</span> <span class="identifier">y</span> <span class="special">?</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">x</span> <span class="special">:</span> <span class="identifier">result</span> <span class="special">==</span> <span class="identifier">y</span><span class="special">,</span>
<span class="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">x</span> <span class="special">&lt;</span> <span class="identifier">y</span> <span class="special">?</span> <span class="identifier">x</span> <span class="special">:</span> <span class="identifier">y</span><span class="special">;</span> <span class="comment">// OK: T is less than comparable `&lt;`.</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: min.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"min.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">min</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">==</span> <span class="number">1</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">min</span><span class="special">(-</span><span class="number">1</span><span class="special">,</span> <span class="special">-</span><span class="number">2</span><span class="special">)</span> <span class="special">==</span> <span class="special">-</span><span class="number">2</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: min_error.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"min.hpp"</span>
<span class="keyword">struct</span> <span class="identifier">num</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">value</span><span class="special">;</span>
<span class="keyword">explicit</span> <span class="identifier">num</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">v</span> <span class="special">=</span> <span class="number">0</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">value</span><span class="special">(</span><span class="identifier">v</span><span class="special">)</span> <span class="special">{}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">min</span><span class="special">(</span><span class="identifier">num</span><span class="special">(</span><span class="number">1</span><span class="special">),</span> <span class="identifier">num</span><span class="special">(</span><span class="number">2</span><span class="special">));</span> <span class="comment">// Compiler error: Fail concept requirements.</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Meyer97] Stack4: Comparison with Eiffel syntax"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__meyer97___stack4__comparison_with_eiffel_syntax"></a><a class="link" href="#contract__.examples.__meyer97___stack4__comparison_with_eiffel_syntax" title="[Meyer97] Stack4: Comparison with Eiffel syntax">[Meyer97]
Stack4: Comparison with Eiffel syntax</a></h3></div></div></div><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
This Library (C++03)
</p>
</th><th>
<p>
The Eiffel Programming Language
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: stack4.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">STACK4_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">STACK4_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">// Specification.</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Dispenser with LIFO access policy and a fixed max capacity.</span>
<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="special">(</span><span class="identifier">stack4</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">,</span> <span class="comment">// count non negative</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">(),</span> <span class="comment">// count bounded</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="comment">// empty if no elements</span>
<span class="special">)</span>
<span class="comment">// Initialization.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Allocate stack for a maximum of n elements.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">stack4</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">&amp;)</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">n</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="comment">// non negative capacity</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">n</span> <span class="comment">// capacity set</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred body definition (see bottom).</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Deep copy.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">stack4</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">stack4</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span>
<span class="comment">// all items equal right's items one by one</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Deep assignment.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">stack4</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">(=)(</span><span class="identifier">assign</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">stack4</span><span class="special">&amp;)</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span>
<span class="comment">// all items equal right's items one by one</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Destroy this stack.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">stack4</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Access.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Max number of stack elements.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">capacity</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Number of stack elements.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Top element.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">item</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="comment">// not empty (i.e., count &gt; 0)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Status report.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Is stack empty?</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="comment">// empty definition</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Is stack full?</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">full</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">capacity</span><span class="special">())</span> <span class="comment">// full definition</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Element change.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Add x on top.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">full</span><span class="special">()</span> <span class="comment">// not full</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="keyword">not</span> <span class="identifier">empty</span><span class="special">(),</span> <span class="comment">// not empty</span>
<span class="identifier">item</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">x</span><span class="special">,</span> <span class="comment">// added to top</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span> <span class="comment">// one more item</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Remove top item.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">remove</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="comment">// not empty (i.e., count &gt; 0)</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="keyword">not</span> <span class="identifier">full</span><span class="special">(),</span> <span class="comment">// not full</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">-</span> <span class="number">1</span> <span class="comment">// one fewer item</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">capacity_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">count_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">representation_</span><span class="special">;</span> <span class="comment">// Using C-style array.</span>
<span class="special">};</span>
<span class="comment">// Implementation.</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">stack4</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">const</span> <span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">n</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">capacity_</span> <span class="special">=</span> <span class="identifier">n</span><span class="special">;</span>
<span class="identifier">count_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">representation_</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">T</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="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">stack4</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">stack4</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">capacity_</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">capacity_</span><span class="special">;</span>
<span class="identifier">count_</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">count_</span><span class="special">;</span>
<span class="identifier">representation_</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">capacity_</span><span class="special">];</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">count_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="identifier">representation_</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">representation_</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="keyword">operator</span><span class="special">(=)(</span><span class="identifier">assign</span><span class="special">))</span> <span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">stack4</span><span class="special">&amp;</span> <span class="identifier">right</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">representation_</span><span class="special">;</span>
<span class="identifier">capacity_</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">capacity_</span><span class="special">;</span>
<span class="identifier">count_</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">count_</span><span class="special">;</span>
<span class="identifier">representation_</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">capacity_</span><span class="special">];</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">count_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="identifier">representation_</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">representation_</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="keyword">return</span> <span class="special">*</span><span class="keyword">this</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="special">~</span><span class="identifier">stack4</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">representation_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">capacity</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">capacity_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">count_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">item</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">representation_</span><span class="special">[</span><span class="identifier">count</span><span class="special">()</span> <span class="special">-</span> <span class="number">1</span><span class="special">];</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">count</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">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">full</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">representation_</span><span class="special">[</span><span class="identifier">count_</span><span class="special">++]</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;,</span> <span class="identifier">remove</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="special">--</span><span class="identifier">count_</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="special">--</span> <span class="identifier">File</span><span class="special">:</span> <span class="identifier">stack4</span><span class="special">.</span><span class="identifier">e</span>
<span class="special">--</span> <span class="identifier">Extra</span> <span class="identifier">spaces</span><span class="special">,</span> <span class="identifier">newlines</span><span class="special">,</span> <span class="identifier">etc</span> <span class="identifier">used</span> <span class="identifier">to</span> <span class="identifier">align</span> <span class="identifier">text</span> <span class="identifier">with</span> <span class="keyword">this</span> <span class="identifier">library</span> <span class="identifier">code</span><span class="special">.</span>
<span class="identifier">indexing</span>
<span class="identifier">destription</span><span class="special">:</span> <span class="string">"Dispenser with LIFO access policy and a fixed max capacity."</span>
<span class="keyword">class</span> <span class="identifier">interface</span> <span class="identifier">STACK4</span><span class="special">[</span><span class="identifier">G</span><span class="special">]</span> <span class="identifier">creation</span> <span class="identifier">make</span>
<span class="identifier">invariant</span>
<span class="identifier">count_non_negative</span><span class="special">:</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span>
<span class="identifier">count_bounded</span><span class="special">:</span> <span class="identifier">count</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span>
<span class="identifier">empty_if_no_elements</span><span class="special">:</span> <span class="identifier">empty</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">count</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span>
<span class="identifier">feature</span> <span class="special">--</span> <span class="identifier">Initialization</span><span class="special">.</span>
<span class="special">--</span> <span class="identifier">Allocate</span> <span class="identifier">stack</span> <span class="keyword">for</span> <span class="identifier">a</span> <span class="identifier">maximum</span> <span class="identifier">of</span> <span class="identifier">n</span> <span class="identifier">elements</span><span class="special">.</span>
<span class="identifier">make</span> <span class="special">(</span> <span class="identifier">n</span> <span class="special">:</span> <span class="identifier">INTEGER</span> <span class="special">)</span> <span class="identifier">is</span>
<span class="identifier">require</span>
<span class="identifier">non_negative_capacity</span><span class="special">:</span> <span class="identifier">n</span> <span class="special">&gt;=</span> <span class="number">0</span>
<span class="identifier">ensure</span>
<span class="identifier">capacity_set</span><span class="special">:</span> <span class="identifier">capacity</span> <span class="special">=</span> <span class="identifier">n</span>
<span class="identifier">end</span>
<span class="identifier">feature</span> <span class="special">--</span> <span class="identifier">Access</span><span class="special">.</span>
<span class="special">--</span> <span class="identifier">Max</span> <span class="identifier">number</span> <span class="identifier">of</span> <span class="identifier">stack</span> <span class="identifier">elements</span><span class="special">.</span>
<span class="identifier">capacity</span> <span class="special">:</span> <span class="identifier">INTEGER</span>
<span class="special">--</span> <span class="identifier">Number</span> <span class="identifier">of</span> <span class="identifier">stack</span> <span class="identifier">elements</span><span class="special">.</span>
<span class="identifier">count</span> <span class="special">:</span> <span class="identifier">INTEGER</span>
<span class="special">--</span> <span class="identifier">Top</span> <span class="identifier">element</span>
<span class="identifier">item</span> <span class="special">:</span> <span class="identifier">G</span> <span class="identifier">is</span>
<span class="identifier">require</span>
<span class="identifier">not_empty</span><span class="special">:</span> <span class="keyword">not</span> <span class="identifier">empty</span> <span class="special">--</span> <span class="identifier">i</span><span class="special">.</span><span class="identifier">e</span><span class="special">.,</span> <span class="identifier">count</span> <span class="special">&gt;</span> <span class="number">0</span>
<span class="identifier">end</span>
<span class="identifier">feature</span> <span class="special">--</span> <span class="identifier">Status</span> <span class="identifier">report</span><span class="special">.</span>
<span class="special">--</span> <span class="identifier">Is</span> <span class="identifier">stack</span> <span class="identifier">empty</span><span class="special">?</span>
<span class="identifier">empty</span> <span class="special">:</span> <span class="identifier">BOOLEAN</span> <span class="identifier">is</span>
<span class="identifier">ensure</span>
<span class="identifier">empty_definition</span><span class="special">:</span> <span class="identifier">result</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">count</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span>
<span class="identifier">end</span>
<span class="special">--</span> <span class="identifier">Is</span> <span class="identifier">stack</span> <span class="identifier">full</span><span class="special">?</span>
<span class="identifier">full</span> <span class="special">:</span> <span class="identifier">BOOLEAN</span> <span class="identifier">is</span>
<span class="identifier">ensure</span>
<span class="identifier">full_definition</span><span class="special">:</span> <span class="identifier">result</span> <span class="special">=</span> <span class="special">(</span><span class="identifier">count</span> <span class="special">=</span> <span class="identifier">capacity</span><span class="special">)</span>
<span class="identifier">end</span>
<span class="identifier">feature</span> <span class="special">--</span> <span class="identifier">Element</span> <span class="identifier">change</span><span class="special">.</span>
<span class="special">--</span> <span class="identifier">Add</span> <span class="identifier">x</span> <span class="identifier">on</span> <span class="identifier">top</span><span class="special">.</span>
<span class="identifier">put</span> <span class="special">(</span> <span class="identifier">x</span> <span class="special">:</span> <span class="identifier">G</span> <span class="special">)</span> <span class="identifier">is</span>
<span class="identifier">require</span>
<span class="identifier">not_full</span><span class="special">:</span> <span class="keyword">not</span> <span class="identifier">full</span>
<span class="identifier">ensure</span>
<span class="identifier">not_empty</span><span class="special">:</span> <span class="keyword">not</span> <span class="identifier">empty</span>
<span class="identifier">added_to_top</span><span class="special">:</span> <span class="identifier">item</span> <span class="special">=</span> <span class="identifier">x</span>
<span class="identifier">one_more_item</span><span class="special">:</span> <span class="identifier">count</span> <span class="special">=</span> <span class="identifier">old</span> <span class="identifier">count</span> <span class="special">+</span> <span class="number">1</span>
<span class="identifier">end</span>
<span class="special">--</span> <span class="identifier">Remove</span> <span class="identifier">top</span> <span class="identifier">element</span><span class="special">.</span>
<span class="identifier">remove</span> <span class="identifier">is</span>
<span class="identifier">require</span>
<span class="identifier">not_empty</span><span class="special">:</span> <span class="keyword">not</span> <span class="identifier">empty</span> <span class="special">--</span> <span class="identifier">i</span><span class="special">.</span><span class="identifier">e</span><span class="special">.,</span> <span class="identifier">count</span> <span class="special">&gt;</span> <span class="number">0</span>
<span class="identifier">ensure</span>
<span class="identifier">not_full</span><span class="special">:</span> <span class="keyword">not</span> <span class="identifier">full</span>
<span class="identifier">one_fewer_item</span><span class="special">:</span> <span class="identifier">count</span> <span class="special">=</span> <span class="identifier">old</span> <span class="identifier">count</span> <span class="special">-</span> <span class="number">1</span>
<span class="identifier">end</span>
<span class="identifier">end</span> <span class="special">--</span> <span class="keyword">class</span> <span class="identifier">interface</span> <span class="identifier">STACK4</span>
</pre><p>
</p>
</td></tr><tr><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: stack4_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"stack4.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">stack4</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">s</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">empty</span><span class="special">());</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">full</span><span class="special">());</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">item</span><span class="special">()</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">remove</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">empty</span><span class="special">());</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p>
</td><td>
</td></tr></tbody></table></div></div><div class="section" title="[Meyer97] Stack3: Error codes instead of preconditions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__meyer97___stack3__error_codes_instead_of_preconditions"></a><a class="link" href="#contract__.examples.__meyer97___stack3__error_codes_instead_of_preconditions" title="[Meyer97] Stack3: Error codes instead of preconditions">[Meyer97]
Stack3: Error codes instead of preconditions</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: stack3.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"stack4.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Dispenser LIFO and max capacity using error codes.</span>
<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="special">(</span><span class="identifier">stack3</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no class invariant</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">enum</span> <span class="identifier">Error</span> <span class="special">{</span> <span class="comment">// Error codes.</span>
<span class="identifier">NO_ERROR</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span>
<span class="identifier">OVERFLOW_ERROR</span><span class="special">,</span>
<span class="identifier">UNDERFLOW_ERROR</span><span class="special">,</span>
<span class="identifier">SIZE_ERROR</span>
<span class="special">};</span>
<span class="comment">// Initialization.</span>
<span class="comment">// Create stack for max of n elements, if n &lt; 0 set error (no precondition).</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">stack3</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">&amp;)</span> <span class="identifier">n</span><span class="special">,</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">none</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">T</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">bool</span><span class="special">(</span><span class="identifier">n</span> <span class="special">&lt;</span> <span class="number">0</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">error</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">SIZE_ERROR</span><span class="special">),</span> <span class="comment">// error if impossible</span>
<span class="keyword">bool</span><span class="special">(</span><span class="identifier">n</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">)</span> <span class="special">==</span> <span class="special">!</span><span class="identifier">error</span><span class="special">(),</span> <span class="comment">// no error if possible</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">bool</span><span class="special">(!</span><span class="identifier">error</span><span class="special">()))</span> <span class="special">(</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">n</span> <span class="special">)</span> <span class="comment">// created if no error</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">none_</span><span class="special">(</span><span class="identifier">none</span><span class="special">),</span> <span class="identifier">representation_</span><span class="special">(</span><span class="number">0</span><span class="special">),</span> <span class="identifier">error_</span><span class="special">(</span><span class="identifier">NO_ERROR</span><span class="special">)</span> <span class="special">)</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">&gt;=</span> <span class="number">0</span><span class="special">)</span> <span class="identifier">representation_</span> <span class="special">=</span> <span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">n</span><span class="special">);</span>
<span class="keyword">else</span> <span class="identifier">error_</span> <span class="special">=</span> <span class="identifier">SIZE_ERROR</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Destroy stack.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">stack3</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Access.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Max number of stack elements.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">capacity</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">representation_</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Number of stack elements.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">representation_</span><span class="special">.</span><span class="identifier">count</span><span class="special">();</span>
<span class="special">}</span>
<span class="comment">// Top element if present, otherwise set error (no precondition).</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">item</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">error</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">UNDERFLOW_ERROR</span><span class="special">),</span> <span class="comment">// error if impossible</span>
<span class="keyword">bool</span><span class="special">(!</span><span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">!</span><span class="identifier">error</span><span class="special">())</span> <span class="comment">// no error if possible</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(!</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span>
<span class="identifier">error_</span> <span class="special">=</span> <span class="identifier">NO_ERROR</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">representation_</span><span class="special">.</span><span class="identifier">item</span><span class="special">();</span>
<span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
<span class="identifier">error_</span> <span class="special">=</span> <span class="identifier">UNDERFLOW_ERROR</span><span class="special">;</span>
<span class="keyword">return</span> <span class="identifier">none_</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="comment">// Status report.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Error indicator set by various operations.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">Error</span><span class="special">)</span> <span class="special">(</span><span class="identifier">error</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">error_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Is stack empty?</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">representation_</span><span class="special">.</span><span class="identifier">empty</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Is stack full?</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">full</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">representation_</span><span class="special">.</span><span class="identifier">full</span><span class="special">();</span>
<span class="special">}</span>
<span class="comment">// Element change.</span>
<span class="comment">// Add x to top if capacity left, otherwise set error (no precondition).</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;)</span> <span class="identifier">x</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_full</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">full</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">old_full</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">error</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">OVERFLOW_ERROR</span><span class="special">),</span> <span class="comment">// error if impossible</span>
<span class="keyword">not</span> <span class="identifier">old_full</span> <span class="special">==</span> <span class="keyword">not</span> <span class="identifier">error</span><span class="special">(),</span> <span class="comment">// no error if possible</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">error</span><span class="special">())</span> <span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">empty</span><span class="special">(),</span> <span class="comment">// not empty if no error</span>
<span class="identifier">item</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">x</span><span class="special">,</span> <span class="comment">// added to top is no error</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span> <span class="comment">// one more item if no error</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">full</span><span class="special">())</span> <span class="special">{</span>
<span class="identifier">error_</span> <span class="special">=</span> <span class="identifier">OVERFLOW_ERROR</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
<span class="identifier">representation_</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="identifier">error_</span> <span class="special">=</span> <span class="identifier">NO_ERROR</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="comment">// Remove top item if possible, otherwise set error to (no precondition).</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">remove</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_empty</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">empty</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">old_empty</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">error</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">UNDERFLOW_ERROR</span><span class="special">),</span> <span class="comment">// if impossible</span>
<span class="keyword">not</span> <span class="identifier">old_empty</span> <span class="special">==</span> <span class="keyword">not</span> <span class="identifier">error</span><span class="special">(),</span> <span class="comment">// no error if possible</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">error</span><span class="special">())</span> <span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">full</span><span class="special">(),</span> <span class="comment">// not full is no error</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">-</span> <span class="number">1</span> <span class="comment">// one fewer item if no error</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">{</span>
<span class="identifier">error_</span> <span class="special">=</span> <span class="identifier">UNDERFLOW_ERROR</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
<span class="identifier">representation_</span><span class="special">.</span><span class="identifier">remove</span><span class="special">();</span>
<span class="identifier">error_</span> <span class="special">=</span> <span class="identifier">NO_ERROR</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">none_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">stack4</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">representation_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">mutable</span> <span class="identifier">Error</span> <span class="identifier">error_</span><span class="special">;</span> <span class="comment">// Mutable for logic constantness.</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">stack3</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">s</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">empty</span><span class="special">());</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">full</span><span class="special">());</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">item</span><span class="special">()</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">remove</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">empty</span><span class="special">());</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Meyer97] GCD: Loop variants and invariants plus comparison with Eiffel syntax"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__meyer97___gcd__loop_variants_and_invariants_plus_comparison_with_eiffel_syntax"></a><a class="link" href="#contract__.examples.__meyer97___gcd__loop_variants_and_invariants_plus_comparison_with_eiffel_syntax" title="[Meyer97] GCD: Loop variants and invariants plus comparison with Eiffel syntax">[Meyer97]
GCD: Loop variants and invariants plus comparison with Eiffel syntax</a></h3></div></div></div><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
This Library (C++03)
</p>
</th><th>
<p>
The Eiffel Programming Language
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: gcd.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Great common divisor of given positive integers.</span>
<span class="keyword">int</span> <span class="special">(</span><span class="identifier">gcd</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">a</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">b</span> <span class="special">&gt;</span> <span class="number">0</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">b</span><span class="special">;</span>
<span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="keyword">while</span><span class="special">(</span><span class="identifier">x</span> <span class="special">!=</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">// Loop contracted with a variant.</span>
<span class="comment">// Block invariant assert loop invariant.</span>
<span class="identifier">CONTRACT_BLOCK_INVARIANT</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">x</span> <span class="special">)</span> <span class="identifier">x</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">,</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">y</span> <span class="special">)</span> <span class="identifier">y</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span>
<span class="comment">// Loop variant is non-negative and monotonically decreasing.</span>
<span class="identifier">CONTRACT_LOOP_VARIANT</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">x</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">max</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">)</span>
<span class="comment">// `x` and `y` have the same GCD as `a` and `b`. </span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">x</span> <span class="special">&gt;</span> <span class="identifier">y</span><span class="special">)</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">x</span> <span class="special">-</span> <span class="identifier">y</span><span class="special">;</span> <span class="keyword">else</span> <span class="identifier">y</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="keyword">return</span> <span class="identifier">x</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">gcd</span><span class="special">(</span><span class="number">12</span><span class="special">,</span> <span class="number">18</span><span class="special">)</span> <span class="special">==</span> <span class="number">6</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">gcd</span><span class="special">(</span><span class="number">4</span><span class="special">,</span> <span class="number">14</span><span class="special">)</span> <span class="special">==</span> <span class="number">2</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="special">--</span> <span class="identifier">File</span><span class="special">:</span> <span class="identifier">gcd</span><span class="special">.</span><span class="identifier">e</span>
<span class="special">--</span> <span class="identifier">Extra</span> <span class="identifier">spaces</span><span class="special">,</span> <span class="identifier">newlines</span><span class="special">,</span> <span class="identifier">etc</span> <span class="identifier">used</span> <span class="identifier">to</span> <span class="identifier">align</span> <span class="identifier">text</span> <span class="identifier">with</span> <span class="keyword">this</span> <span class="identifier">library</span> <span class="identifier">code</span><span class="special">.</span>
<span class="special">--</span> <span class="identifier">Greatest</span> <span class="identifier">common</span> <span class="identifier">divisor</span> <span class="identifier">of</span> <span class="identifier">a</span> <span class="keyword">and</span> <span class="identifier">b</span><span class="special">.</span>
<span class="identifier">gcd</span> <span class="special">(</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span> <span class="special">:</span> <span class="identifier">INTEGER</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">INTEGER</span> <span class="identifier">is</span>
<span class="identifier">require</span>
<span class="identifier">a</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">b</span> <span class="special">&gt;</span> <span class="number">0</span>
<span class="identifier">local</span>
<span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">:</span> <span class="identifier">INTEGER</span>
<span class="keyword">do</span>
<span class="identifier">from</span>
<span class="identifier">x</span> <span class="special">:=</span> <span class="identifier">a</span><span class="special">;</span> <span class="identifier">y</span> <span class="special">:=</span> <span class="identifier">b</span>
<span class="identifier">invariant</span>
<span class="identifier">x</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">y</span> <span class="special">&gt;</span> <span class="number">0</span>
<span class="identifier">variant</span>
<span class="identifier">x</span><span class="special">.</span><span class="identifier">max</span><span class="special">(</span><span class="identifier">y</span><span class="special">)</span>
<span class="identifier">until</span>
<span class="identifier">x</span> <span class="special">=</span> <span class="identifier">y</span>
<span class="identifier">loop</span>
<span class="keyword">if</span> <span class="identifier">x</span> <span class="special">&gt;</span> <span class="identifier">y</span> <span class="identifier">then</span> <span class="identifier">x</span> <span class="special">:=</span> <span class="identifier">x</span> <span class="special">-</span> <span class="identifier">y</span> <span class="keyword">else</span> <span class="identifier">y</span> <span class="special">:=</span> <span class="identifier">y</span> <span class="special">-</span> <span class="identifier">x</span> <span class="identifier">end</span>
<span class="identifier">end</span>
<span class="identifier">Result</span> <span class="special">:=</span> <span class="identifier">x</span>
<span class="identifier">end</span>
</pre><p>
</p>
</td></tr></tbody></table></div></div><div class="section" title="[Meyer97] Max-Array: Nested loop variants and invariants"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__meyer97___max_array__nested_loop_variants_and_invariants"></a><a class="link" href="#contract__.examples.__meyer97___max_array__nested_loop_variants_and_invariants" title="[Meyer97] Max-Array: Nested loop variants and invariants">[Meyer97]
Max-Array: Nested loop variants and invariants</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: maxarray.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">int</span> <span class="special">(</span><span class="identifier">maxarray</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span> <span class="keyword">const</span><span class="special">)</span> <span class="identifier">array</span><span class="special">,</span> <span class="special">(</span><span class="identifier">size_t</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">size</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">array</span><span class="special">,</span> <span class="comment">// array allocated</span>
<span class="identifier">size</span> <span class="special">&gt;=</span> <span class="number">1</span> <span class="comment">// size in range</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">maxnow</span> <span class="special">=</span> <span class="identifier">array</span><span class="special">[</span><span class="number">0</span><span class="special">];</span>
<span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="special">(</span><span class="identifier">size</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="special">)</span> <span class="special">{</span>
<span class="comment">// Nested loop (with variant) used to assert enclosing loop invariants.</span>
<span class="identifier">CONTRACT_LOOP</span><span class="special">(</span> <span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">j</span> <span class="special">&lt;</span> <span class="identifier">i</span><span class="special">;</span> <span class="special">++</span><span class="identifier">j</span><span class="special">)</span> <span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_LOOP_VARIANT</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span> <span class="identifier">i</span> <span class="special">-</span> <span class="identifier">j</span> <span class="special">)</span>
<span class="identifier">CONTRACT_BLOCK_INVARIANT</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">maxnow</span><span class="special">,</span> <span class="identifier">array</span><span class="special">,</span> <span class="identifier">j</span> <span class="special">)</span>
<span class="identifier">maxnow</span> <span class="special">&gt;=</span> <span class="identifier">array</span><span class="special">[</span><span class="identifier">j</span><span class="special">]</span> <span class="special">)</span>
<span class="special">}</span>
<span class="comment">// -2 because starts from 0 (not 1) and already done element at 0.</span>
<span class="identifier">CONTRACT_LOOP_VARIANT</span><span class="special">(</span> <span class="keyword">const</span><span class="special">(</span> <span class="identifier">size</span><span class="special">,</span> <span class="identifier">i</span> <span class="special">)</span> <span class="identifier">size</span> <span class="special">-</span> <span class="identifier">i</span> <span class="special">-</span> <span class="number">2</span> <span class="special">)</span>
<span class="identifier">maxnow</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">max</span><span class="special">(</span><span class="identifier">maxnow</span><span class="special">,</span> <span class="identifier">array</span><span class="special">[</span><span class="identifier">i</span><span class="special">]);</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="identifier">maxnow</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">a</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span><span class="number">1</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="number">3</span><span class="special">};</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">maxarray</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span> <span class="special">==</span> <span class="number">5</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Name List: Relaxed subcontracts"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___name_list__relaxed_subcontracts"></a><a class="link" href="#contract__.examples.__mitchell02___name_list__relaxed_subcontracts" title="[Mitchell02] Name List: Relaxed subcontracts">[Mitchell02]
Name List: Relaxed subcontracts</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: name_list.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">NAME_LIST_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">NAME_LIST_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">string</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">list</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// List of names.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">name_list</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// non-negative count</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create an empty list.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// empty list</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred body definition.</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy list.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Number of names in list.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="comment">// postcondition: non-negative count already in class invariants</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Is name in list?</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">has</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">name</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">count</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">not</span> <span class="identifier">result</span> <span class="special">)</span> <span class="comment">// does not have is empty</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Add name to list.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">name</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">has</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span> <span class="comment">// not already in list</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_has_name</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">has</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="comment">// Following if-guard allows to relax subcontracts.</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">old_has_name</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">has</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span> <span class="comment">// name on list</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span> <span class="comment">// number of names increased</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">names_</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// List of names that allows for duplicates.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">relaxed_name_list</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">name_list</span> <span class="special">)</span> <span class="comment">// Subcontracting.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no subcontracted invariants</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create an empty list.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">relaxed_name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy list.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">relaxed_name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Add name to list.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">name</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="comment">// Relax inherited precondition.</span>
<span class="identifier">has</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span> <span class="comment">// already in list</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_has_name</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">has</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="comment">// Inherited postconditions not checked because of its if-guard.</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">old_has_name</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="comment">// unchanged if name already in list</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: name_list.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"name_list.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="comment">// name_list</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">name_list</span><span class="special">,</span> <span class="identifier">name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">name_list</span><span class="special">,</span> <span class="special">~</span><span class="identifier">name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="keyword">int</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">name_list</span><span class="special">,</span> <span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">names_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">bool</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">name_list</span><span class="special">,</span> <span class="identifier">has</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">name</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">names_</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">!=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">names_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">names_</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">name</span><span class="special">);</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">name_list</span><span class="special">,</span> <span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">name</span> <span class="special">)</span>
<span class="special">{</span> <span class="identifier">names_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">name</span><span class="special">);</span> <span class="special">}</span>
<span class="comment">// relaxed_name_list</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">relaxed_name_list</span><span class="special">,</span> <span class="identifier">relaxed_name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">relaxed_name_list</span><span class="special">,</span> <span class="special">~</span><span class="identifier">relaxed_name_list</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">relaxed_name_list</span><span class="special">,</span> <span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">name</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// Must use `BODY` to call base functions (to avoid infinite recursion).</span>
<span class="keyword">if</span><span class="special">(!</span><span class="identifier">has</span><span class="special">(</span><span class="identifier">name</span><span class="special">))</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">name_list</span><span class="special">,</span> <span class="identifier">put</span><span class="special">)(</span><span class="identifier">name</span><span class="special">);</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: name_list_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"name_list.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">relaxed_name_list</span> <span class="identifier">rl</span><span class="special">;</span>
<span class="identifier">rl</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="string">"abc"</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">rl</span><span class="special">.</span><span class="identifier">has</span><span class="special">(</span><span class="string">"abc"</span><span class="special">));</span>
<span class="identifier">rl</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="string">"abc"</span><span class="special">);</span> <span class="comment">// Note: Can call `put("abc")` this gain.</span>
<span class="identifier">name_list</span> <span class="identifier">nl</span><span class="special">;</span>
<span class="identifier">nl</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="string">"abc"</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">nl</span><span class="special">.</span><span class="identifier">has</span><span class="special">(</span><span class="string">"abc"</span><span class="special">));</span>
<span class="comment">// Note: Cannot call `put("abc")` again.</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Dictionary: Simple key-value map"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___dictionary__simple_key_value_map"></a><a class="link" href="#contract__.examples.__mitchell02___dictionary__simple_key_value_map" title="[Mitchell02] Dictionary: Simple key-value map">[Mitchell02]
Dictionary: Simple key-value map</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: dictionary.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">utility</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">map</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Simple dictionary.</span>
<span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">Key</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Value</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">dictionary</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// non-negative count</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Create empty dictionary.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">dictionary</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// empty</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Destroy dictionary.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">dictionary</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Basic queries.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Number of key entires.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="comment">// postcondition: non-negative count asserted by class invariants</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Has entry for key?</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">has</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">key</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">count</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">not</span> <span class="identifier">result</span> <span class="special">)</span> <span class="comment">// empty has no key</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Value for given key.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">Value</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">value_for</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">key</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">has</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// has key</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">key</span><span class="special">)-&gt;</span><span class="identifier">second</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Put value for given key.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">key</span><span class="special">,</span> <span class="special">(</span><span class="identifier">Value</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="comment">// count increased</span>
<span class="identifier">has</span><span class="special">(</span><span class="identifier">key</span><span class="special">),</span> <span class="comment">// has key</span>
<span class="identifier">value_for</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">value</span> <span class="comment">// value for key set</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">items_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">key</span><span class="special">,</span> <span class="identifier">value</span><span class="special">));</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Remove value for given key.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">remove</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">key</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">has</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// has key</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span> <span class="comment">// count decreased</span>
<span class="keyword">not</span> <span class="identifier">has</span><span class="special">(</span><span class="identifier">key</span><span class="special">)</span> <span class="comment">// does not have key</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">items_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">key</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">Value</span><span class="special">&gt;</span> <span class="identifier">items_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">dictionary</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">ages</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">ages</span><span class="special">.</span><span class="identifier">has</span><span class="special">(</span><span class="string">"john"</span><span class="special">));</span>
<span class="identifier">ages</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="string">"john"</span><span class="special">,</span> <span class="number">23</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">ages</span><span class="special">.</span><span class="identifier">value_for</span><span class="special">(</span><span class="string">"john"</span><span class="special">)</span> <span class="special">==</span> <span class="number">23</span><span class="special">);</span>
<span class="identifier">ages</span><span class="special">.</span><span class="identifier">remove</span><span class="special">(</span><span class="string">"john"</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">ages</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Courier: Subcontracting and static class invariants"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___courier__subcontracting_and_static_class_invariants"></a><a class="link" href="#contract__.examples.__mitchell02___courier__subcontracting_and_static_class_invariants" title="[Mitchell02] Courier: Subcontracting and static class invariants">[Mitchell02]
Courier: Subcontracting and static class invariants</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: courier.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">COURIER_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">COURIER_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">string</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">package</span> <span class="comment">// Basic package information.</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">double</span> <span class="identifier">weight_kg</span><span class="special">;</span> <span class="comment">// Weight in kilograms.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">location</span><span class="special">;</span> <span class="comment">// Current location.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">double</span> <span class="identifier">accepted_hour</span><span class="special">;</span> <span class="comment">// Hour when it was accepted for delivery.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">double</span> <span class="identifier">delivered_hour</span><span class="special">;</span> <span class="comment">// Hour when it was delivered.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">package</span> <span class="special">(</span>
<span class="keyword">double</span> <span class="keyword">const</span> <span class="identifier">a_weight_kg</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">a_location</span> <span class="special">=</span> <span class="string">""</span><span class="special">,</span>
<span class="keyword">double</span> <span class="keyword">const</span> <span class="identifier">an_accepted_hour</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">,</span>
<span class="keyword">double</span> <span class="keyword">const</span> <span class="identifier">a_delivered_hour</span> <span class="special">=</span> <span class="number">0.0</span>
<span class="special">)</span>
<span class="special">:</span> <span class="identifier">weight_kg</span><span class="special">(</span><span class="identifier">a_weight_kg</span><span class="special">),</span>
<span class="identifier">location</span><span class="special">(</span><span class="identifier">a_location</span><span class="special">),</span>
<span class="identifier">accepted_hour</span><span class="special">(</span><span class="identifier">an_accepted_hour</span><span class="special">),</span>
<span class="identifier">delivered_hour</span><span class="special">(</span><span class="identifier">a_delivered_hour</span><span class="special">)</span>
<span class="special">{}</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Basic courier for package delivery.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">courier</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span>
<span class="identifier">insurance_cover_dollar</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">min_insurance_dollar</span><span class="special">,</span> <span class="comment">// above min insur.</span>
<span class="keyword">static</span> <span class="keyword">class</span><span class="special">(</span> <span class="comment">// Static class invariants.</span>
<span class="identifier">min_insurance_dollar</span> <span class="special">&gt;</span> <span class="number">0.0</span> <span class="comment">// positive min insurance</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">double</span> <span class="identifier">min_insurance_dollar</span><span class="special">;</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create courier with specified insurance value.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">courier</span><span class="special">)</span> <span class="special">(</span>
<span class="keyword">double</span> <span class="keyword">const</span> <span class="identifier">an_insurance_cover_dollar</span><span class="special">,</span>
<span class="keyword">default</span> <span class="identifier">min_insurance_dollar</span>
<span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">an_insurance_cover_dollar</span> <span class="special">&gt;</span> <span class="number">0.0</span> <span class="special">)</span> <span class="comment">// positive insur.</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred body definition.</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy courier.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">courier</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Queries.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Return insurance cover.</span>
<span class="keyword">public</span> <span class="keyword">double</span> <span class="special">(</span><span class="identifier">insurance_cover_dollar</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Deliver package to destination.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">deliver</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">package</span><span class="special">&amp;)</span> <span class="identifier">the_package</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">)</span> <span class="identifier">destination</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">the_package</span><span class="special">.</span><span class="identifier">weight_kg</span> <span class="special">&lt;</span> <span class="number">5.0</span> <span class="comment">// within max wight</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">double</span><span class="special">(</span><span class="identifier">the_package</span><span class="special">.</span><span class="identifier">delivered_hour</span> <span class="special">-</span> <span class="identifier">the_package</span><span class="special">.</span><span class="identifier">accepted_hour</span><span class="special">)</span>
<span class="special">&lt;=</span> <span class="number">3.0</span><span class="special">,</span> <span class="comment">// within max delivery time</span>
<span class="identifier">the_package</span><span class="special">.</span><span class="identifier">location</span> <span class="special">==</span> <span class="identifier">destination</span> <span class="comment">// delivered at destination</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">double</span> <span class="identifier">insurance_cover_dollar_</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Different courier for package delivery.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">different_courier</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">courier</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span>
<span class="identifier">insurance_cover_dollar</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">different_insurance_dollar</span><span class="special">,</span>
<span class="keyword">static</span> <span class="keyword">class</span><span class="special">(</span>
<span class="identifier">different_insurance_dollar</span> <span class="special">&gt;=</span> <span class="identifier">courier</span><span class="special">::</span><span class="identifier">min_insurance_dollar</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">static</span> <span class="keyword">double</span> <span class="identifier">different_insurance_dollar</span><span class="special">;</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create currier with specified insurance value.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">different_courier</span><span class="special">)</span> <span class="special">(</span>
<span class="keyword">double</span> <span class="keyword">const</span> <span class="identifier">insurance_cover_dollar</span><span class="special">,</span>
<span class="keyword">default</span> <span class="identifier">different_insurance_dollar</span>
<span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">insurance_cover_dollar</span> <span class="special">&gt;</span> <span class="number">0.0</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">courier</span><span class="special">(</span><span class="identifier">insurance_cover_dollar</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span> <span class="comment">// Cannot separated body definition because has member initializers.</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy courier.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">different_courier</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">deliver</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">package</span><span class="special">&amp;)</span> <span class="identifier">the_package</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">)</span> <span class="identifier">destination</span> <span class="special">)</span> <span class="identifier">override</span> <span class="identifier">final</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="comment">// Weaker precondition on weight (it can weight more).</span>
<span class="identifier">the_package</span><span class="special">.</span><span class="identifier">weight_kg</span> <span class="special">&lt;=</span> <span class="number">8.0</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="comment">// Stronger postcondition on delivery time (faster delivery).</span>
<span class="keyword">double</span><span class="special">(</span><span class="identifier">the_package</span><span class="special">.</span><span class="identifier">delivered_hour</span> <span class="special">-</span> <span class="identifier">the_package</span><span class="special">.</span><span class="identifier">accepted_hour</span><span class="special">)</span>
<span class="special">&lt;=</span> <span class="number">2.0</span>
<span class="comment">// Inherits "delivered at destination" postcondition.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: courier.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"courier.hpp"</span>
<span class="comment">// Courier.</span>
<span class="keyword">double</span> <span class="identifier">courier</span><span class="special">::</span><span class="identifier">min_insurance_dollar</span> <span class="special">=</span> <span class="number">10.0e+6</span><span class="special">;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">courier</span><span class="special">,</span> <span class="identifier">courier</span><span class="special">)</span> <span class="special">(</span>
<span class="keyword">double</span> <span class="keyword">const</span> <span class="identifier">an_insurance_cover_dollar</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">insurance_cover_dollar_</span> <span class="special">=</span> <span class="identifier">an_insurance_cover_dollar</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">courier</span><span class="special">,</span> <span class="special">~</span><span class="identifier">courier</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="keyword">double</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">courier</span><span class="special">,</span> <span class="identifier">insurance_cover_dollar</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">insurance_cover_dollar_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">courier</span><span class="special">,</span> <span class="identifier">deliver</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">package</span><span class="special">&amp;</span> <span class="identifier">the_package</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">destination</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">the_package</span><span class="special">.</span><span class="identifier">location</span> <span class="special">=</span> <span class="identifier">destination</span><span class="special">;</span>
<span class="comment">// Delivery takes 2.5 hours.</span>
<span class="identifier">the_package</span><span class="special">.</span><span class="identifier">delivered_hour</span> <span class="special">=</span> <span class="identifier">the_package</span><span class="special">.</span><span class="identifier">accepted_hour</span> <span class="special">+</span> <span class="number">2.5</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Different courier.</span>
<span class="keyword">double</span> <span class="identifier">different_courier</span><span class="special">::</span><span class="identifier">different_insurance_dollar</span> <span class="special">=</span> <span class="number">20.0e+6</span><span class="special">;</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">different_courier</span><span class="special">,</span> <span class="special">~</span><span class="identifier">different_courier</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">different_courier</span><span class="special">,</span> <span class="identifier">deliver</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">package</span><span class="special">&amp;</span> <span class="identifier">the_package</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">destination</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">the_package</span><span class="special">.</span><span class="identifier">location</span> <span class="special">=</span> <span class="identifier">destination</span><span class="special">;</span>
<span class="comment">// Delivery takes only 0.5 hours.</span>
<span class="identifier">the_package</span><span class="special">.</span><span class="identifier">delivered_hour</span> <span class="special">=</span> <span class="identifier">the_package</span><span class="special">.</span><span class="identifier">accepted_hour</span> <span class="special">+</span> <span class="number">0.5</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: courier_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"courier.hpp"</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">courier</span> <span class="identifier">c</span><span class="special">;</span>
<span class="identifier">different_courier</span> <span class="identifier">dc</span><span class="special">;</span>
<span class="identifier">package</span> <span class="identifier">cups</span><span class="special">(</span><span class="number">3.6</span><span class="special">,</span> <span class="string">"store"</span><span class="special">);</span>
<span class="identifier">package</span> <span class="identifier">desk</span><span class="special">(</span><span class="number">7.2</span><span class="special">,</span> <span class="string">"store"</span><span class="special">);</span>
<span class="identifier">c</span><span class="special">.</span><span class="identifier">deliver</span><span class="special">(</span><span class="identifier">cups</span><span class="special">,</span> <span class="string">"home"</span><span class="special">);</span>
<span class="identifier">dc</span><span class="special">.</span><span class="identifier">deliver</span><span class="special">(</span><span class="identifier">desk</span><span class="special">,</span> <span class="string">"office"</span><span class="special">);</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Stack: Simple stack dispenser"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___stack__simple_stack_dispenser"></a><a class="link" href="#contract__.examples.__mitchell02___stack__simple_stack_dispenser" title="[Mitchell02] Stack: Simple stack dispenser">[Mitchell02]
Stack: Simple stack dispenser</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: stack.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Simple stack.</span>
<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="special">(</span><span class="identifier">stack</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// non-negative count</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Create empty stack.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">stack</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// empty</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Destroy stack.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">stack</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Basic queries.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Number of items.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Item at index in [1, count()] (as in Eiffel).</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">item_at</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="identifier">index</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">index</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">,</span> <span class="comment">// positive index</span>
<span class="identifier">index</span> <span class="special">&lt;=</span> <span class="identifier">count</span><span class="special">()</span> <span class="comment">// index within count</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">index</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
<span class="comment">// Derived queries.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// If no items.</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">is_empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="comment">// consistent with count</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Top item.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">item</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// not empty</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">item_at</span><span class="special">(</span><span class="identifier">count</span><span class="special">())</span> <span class="comment">// item on top</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">item_at</span><span class="special">(</span><span class="identifier">count</span><span class="special">());</span>
<span class="special">}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Push item to the top.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">new_item</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="comment">// count increased</span>
<span class="identifier">item</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">new_item</span> <span class="comment">// item set</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">items_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">new_item</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Pop top item.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">remove</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// not empty</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">-</span> <span class="number">1</span> <span class="comment">// count decreased</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">items_</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span><span class="identifier">items_</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">items_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">stack</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">s</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">);</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">item_at</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">remove</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">is_empty</span><span class="special">());</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Simple Queue: Simple queue dispenser"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___simple_queue__simple_queue_dispenser"></a><a class="link" href="#contract__.examples.__mitchell02___simple_queue__simple_queue_dispenser" title="[Mitchell02] Simple Queue: Simple queue dispenser">[Mitchell02]
Simple Queue: Simple queue dispenser</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: simple_queue.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="comment">// Assertion requirements used to model assertion computational complexity.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_1</span> <span class="number">0</span> <span class="comment">// O(1) constant (default)</span>
<span class="preprocessor">#define</span> <span class="identifier">O_N</span> <span class="number">1</span> <span class="comment">// O(n) linear</span>
<span class="preprocessor">#define</span> <span class="identifier">COMPLEXITY_MAX</span> <span class="identifier">O_1</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">simple_queue</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// non-negative count</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Create empty queue.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">simple_queue</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="identifier">the_capacity</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">the_capacity</span> <span class="special">&gt;</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// positive capacity</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">the_capacity</span><span class="special">,</span> <span class="comment">// capacity set</span>
<span class="identifier">is_empty</span><span class="special">()</span> <span class="comment">// empty</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">items_</span><span class="special">.</span><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">the_capacity</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span> <span class="comment">// Destroy queue.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">simple_queue</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Basic queries.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Items in the queue (in their order).</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">items</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Max number of items queue can hold.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">capacity</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="comment">// Derived queries.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Number of items.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">items</span><span class="special">().</span><span class="identifier">size</span><span class="special">())</span> <span class="comment">// return items count</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Item at head.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">head</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">is_empty</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">items</span><span class="special">().</span><span class="identifier">at</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="comment">// return item on top</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="number">0</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// If queue contains no item.</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">is_empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="comment">// consistent with count</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// If queue has no room for another item.</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">is_full</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="comment">// consistent with size and capacity</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">items</span><span class="special">().</span><span class="identifier">size</span><span class="special">()))</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">items_</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Remove head item and shift all other items.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">remove</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">is_empty</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_items</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">items</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span> <span class="comment">// count decreased</span>
<span class="comment">// Expensive assertion to check so marked with its complexity.</span>
<span class="identifier">all_equal</span><span class="special">(</span><span class="identifier">items</span><span class="special">(),</span> <span class="identifier">old_items</span><span class="special">,</span> <span class="number">1</span> <span class="comment">/* shifted */</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">O_N</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">items_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">items_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">());</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Add item to tail.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">put</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">item</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_items</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">items</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="comment">// count increased</span>
<span class="identifier">items</span><span class="special">().</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">count</span><span class="special">()</span> <span class="special">-</span> <span class="number">1</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">item</span><span class="special">,</span> <span class="comment">// second last item</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">2</span><span class="special">)</span> <span class="special">(</span>
<span class="comment">// Computationally expensive assertion to check.</span>
<span class="identifier">all_equal</span><span class="special">(</span><span class="identifier">items</span><span class="special">(),</span> <span class="identifier">old_items</span><span class="special">),</span>
<span class="identifier">requires</span> <span class="identifier">O_N</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">items_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">item</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span> <span class="comment">// Contract helper.</span>
<span class="keyword">private</span> <span class="keyword">static</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">all_equal</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">left</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">right</span><span class="special">,</span>
<span class="identifier">size_t</span> <span class="identifier">offset</span><span class="special">,</span> <span class="keyword">default</span> <span class="number">0</span>
<span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">right</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">left</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">offset</span> <span class="comment">// correct offset</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">offset</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">i</span> <span class="special">-</span> <span class="identifier">offset</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">right</span><span class="special">.</span><span class="identifier">at</span><span class="special">(</span><span class="identifier">i</span><span class="special">))</span> <span class="keyword">return</span> <span class="keyword">false</span><span class="special">;</span>
<span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">items_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">simple_queue</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">q</span><span class="special">(</span><span class="number">10</span><span class="special">);</span>
<span class="identifier">q</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">q</span><span class="special">.</span><span class="identifier">put</span><span class="special">(</span><span class="number">456</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">items</span> <span class="special">=</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">items</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">items</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">items</span><span class="special">[</span><span class="number">1</span><span class="special">]</span> <span class="special">==</span> <span class="number">456</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">q</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="number">10</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">q</span><span class="special">.</span><span class="identifier">head</span><span class="special">()</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">is_empty</span><span class="special">());</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">q</span><span class="special">.</span><span class="identifier">is_full</span><span class="special">());</span>
<span class="identifier">q</span><span class="special">.</span><span class="identifier">remove</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">q</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">1</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Customer Manager: Contracts instead of Defensive Programming"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___customer_manager__contracts_instead_of_defensive_programming"></a><a class="link" href="#contract__.examples.__mitchell02___customer_manager__contracts_instead_of_defensive_programming" title="[Mitchell02] Customer Manager: Contracts instead of Defensive Programming">[Mitchell02]
Customer Manager: Contracts instead of Defensive Programming</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: customer_manager.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">CUSTOMER_MANAGER_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">CUSTOMER_MANAGER_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">string</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">map</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">basic_customer_details</span> <span class="comment">// Basic customer information.</span>
<span class="special">{</span>
<span class="keyword">friend</span> <span class="keyword">class</span> <span class="identifier">customer_manager</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">identifier</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">basic_customer_details</span> <span class="special">(</span> <span class="identifier">identifier</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">an_id</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">id</span><span class="special">(</span><span class="identifier">an_id</span><span class="special">),</span> <span class="identifier">name</span><span class="special">(),</span> <span class="identifier">address</span><span class="special">(),</span> <span class="identifier">birthday</span><span class="special">()</span>
<span class="special">{}</span>
<span class="keyword">protected</span><span class="special">:</span> <span class="identifier">identifier</span> <span class="identifier">id</span><span class="special">;</span> <span class="comment">// Customer identifier.</span>
<span class="keyword">protected</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">name</span><span class="special">;</span> <span class="comment">// Customer name.</span>
<span class="keyword">protected</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">address</span><span class="special">;</span> <span class="comment">// Customer address.</span>
<span class="keyword">protected</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">birthday</span><span class="special">;</span> <span class="comment">// Customer date of birth.</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Manage customers.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">customer_manager</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="identifier">count</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span> <span class="comment">// non-negative count</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">customer_manager</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="comment">// LIMITATION: Cannot use member initializes because deferring</span>
<span class="comment">// body definition.</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred body definition.</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">customer_manager</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Basic queries.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="comment">// postcondition: non-negative count asserted by class invariants</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// There is a customer with given identifier.</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">id_active</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">basic_customer_details</span><span class="special">::</span><span class="identifier">identifier</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">id</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Derived queries.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Name of customer with given identifier.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="special">(</span><span class="identifier">name_for</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">basic_customer_details</span><span class="special">::</span><span class="identifier">identifier</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">id</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">id_active</span><span class="special">(</span><span class="identifier">id</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// id active</span>
<span class="special">)</span> <span class="special">;</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Add given customer.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">add</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">basic_customer_details</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">details</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">id_active</span><span class="special">(</span><span class="identifier">details</span><span class="special">.</span><span class="identifier">id</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// id not active</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_count</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">count</span><span class="special">(),</span>
<span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_count</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="comment">// count increased</span>
<span class="identifier">id_active</span><span class="special">(</span><span class="identifier">details</span><span class="special">.</span><span class="identifier">id</span><span class="special">)</span> <span class="comment">// id active</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Set name of customer with given identifier.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">set_name</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">basic_customer_details</span><span class="special">::</span><span class="identifier">identifier</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">id</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">name</span>
<span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">id_active</span><span class="special">(</span><span class="identifier">id</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// id active</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">name_for</span><span class="special">(</span><span class="identifier">id</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">name</span> <span class="special">)</span> <span class="comment">// name set</span>
<span class="special">)</span> <span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">class</span> <span class="identifier">agent</span> <span class="special">{};</span> <span class="comment">// Customer agent.</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">struct</span> <span class="identifier">customer</span> <span class="special">:</span> <span class="identifier">basic_customer_details</span> <span class="comment">// Basic customer.</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">agent</span> <span class="identifier">managing_agent</span><span class="special">;</span> <span class="comment">// Customer agent.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">last_contact</span><span class="special">;</span> <span class="comment">// Customer last contacted.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">customer</span> <span class="special">(</span> <span class="identifier">basic_customer_details</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">details</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">basic_customer_details</span><span class="special">(</span><span class="identifier">details</span><span class="special">),</span> <span class="identifier">managing_agent</span><span class="special">(),</span>
<span class="identifier">last_contact</span><span class="special">()</span>
<span class="special">{}</span>
<span class="special">};</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">basic_customer_details</span><span class="special">::</span><span class="identifier">identifier</span><span class="special">,</span> <span class="identifier">customer</span><span class="special">&gt;</span> <span class="identifier">customers_</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: customer_manager.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"customer_manager.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">utility</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">customer_manager</span><span class="special">,</span> <span class="identifier">customer_manager</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">customer_manager</span><span class="special">,</span> <span class="special">~</span><span class="identifier">customer_manager</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">{}</span>
<span class="keyword">int</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">customer_manager</span><span class="special">,</span> <span class="identifier">count</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">customers_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span> <span class="special">}</span>
<span class="keyword">bool</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">customer_manager</span><span class="special">,</span> <span class="identifier">id_active</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">basic_customer_details</span><span class="special">::</span><span class="identifier">identifier</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">id</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">customers_</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">id</span><span class="special">)</span> <span class="special">!=</span> <span class="identifier">customers_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">customer_manager</span><span class="special">,</span> <span class="identifier">name_for</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">basic_customer_details</span><span class="special">::</span><span class="identifier">identifier</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">id</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="comment">// Find != end because of `id_active()` pre so no defensive programming.</span>
<span class="keyword">return</span> <span class="identifier">customers_</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">id</span><span class="special">)-&gt;</span><span class="identifier">second</span><span class="special">.</span><span class="identifier">name</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">customer_manager</span><span class="special">,</span> <span class="identifier">add</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">basic_customer_details</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">details</span> <span class="special">)</span>
<span class="special">{</span> <span class="identifier">customers_</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">details</span><span class="special">.</span><span class="identifier">id</span><span class="special">,</span> <span class="identifier">customer</span><span class="special">(</span><span class="identifier">details</span><span class="special">)));</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">customer_manager</span><span class="special">,</span> <span class="identifier">set_name</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">basic_customer_details</span><span class="special">::</span><span class="identifier">identifier</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">id</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">name</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// Find != end because of `id_active()` pre so no defensive programming.</span>
<span class="identifier">customers_</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">id</span><span class="special">)-&gt;</span><span class="identifier">second</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: customer_manager_main.cpp </span>
<span class="preprocessor">#include</span> <span class="string">"customer_manager.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">customer_manager</span> <span class="identifier">mgr</span><span class="special">;</span>
<span class="identifier">basic_customer_details</span> <span class="identifier">d</span><span class="special">(</span><span class="string">"id1"</span><span class="special">);</span>
<span class="identifier">mgr</span><span class="special">.</span><span class="identifier">add</span><span class="special">(</span><span class="identifier">d</span><span class="special">);</span>
<span class="identifier">mgr</span><span class="special">.</span><span class="identifier">set_name</span><span class="special">(</span><span class="string">"id1"</span><span class="special">,</span> <span class="string">"abc"</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">mgr</span><span class="special">.</span><span class="identifier">name_for</span><span class="special">(</span><span class="string">"id1"</span><span class="special">)</span> <span class="special">==</span> <span class="string">"abc"</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">mgr</span><span class="special">.</span><span class="identifier">count</span><span class="special">()</span> <span class="special">==</span> <span class="number">1</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">mgr</span><span class="special">.</span><span class="identifier">id_active</span><span class="special">(</span><span class="string">"id1"</span><span class="special">));</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Observer: Contracts for pure virtual functions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___observer__contracts_for_pure_virtual_functions"></a><a class="link" href="#contract__.examples.__mitchell02___observer__contracts_for_pure_virtual_functions" title="[Mitchell02] Observer: Contracts for pure virtual functions">[Mitchell02]
Observer: Contracts for pure virtual functions</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: observer/observer.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">OBSERVER_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">OBSERVER_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Observer.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">observer</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no invariant</span>
<span class="keyword">friend</span> <span class="keyword">class</span> <span class="identifier">subject</span><span class="special">;</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create observer.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">observer</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy observer.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">observer</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// If up to date with its subject.</span>
<span class="keyword">protected</span> <span class="keyword">virtual</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">up_to_date_with_subject</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="keyword">new</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Update and inform its subject.</span>
<span class="keyword">protected</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">update</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">new</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">up_to_date_with_subject</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// up-to-date</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: observer/subject.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">SUBJECT_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">SUBJECT_HPP_</span>
<span class="preprocessor">#include</span> <span class="string">"observer.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">list</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="comment">// Assertion requirements used to model assertion computational complexity.</span>
<span class="preprocessor">#define</span> <span class="identifier">O_1</span> <span class="number">0</span> <span class="comment">// O(1) constant (default)</span>
<span class="preprocessor">#define</span> <span class="identifier">O_N</span> <span class="number">1</span> <span class="comment">// O(n) linear</span>
<span class="preprocessor">#define</span> <span class="identifier">COMPLEXITY_MAX</span> <span class="identifier">O_1</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Subject for observer design pattern.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">subject</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span>
<span class="identifier">all_observers_valid</span><span class="special">(</span><span class="identifier">observers</span><span class="special">()),</span> <span class="comment">// observes valid</span>
<span class="identifier">requires</span> <span class="identifier">O_N</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span>
<span class="special">)</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Construct subject with no observer.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">subject</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy subject.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">subject</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Queries.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// If given observer is attached.</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">attached</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*</span> <span class="keyword">const</span><span class="special">)</span> <span class="identifier">obs</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">obs</span> <span class="special">)</span> <span class="comment">// not null</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">(</span><span class="identifier">observers_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">observers_</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">obs</span><span class="special">)</span> <span class="special">!=</span>
<span class="identifier">observers_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span>
<span class="special">}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Remember given object as an observer.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">attach</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">observer</span><span class="special">*</span> <span class="keyword">const</span><span class="special">)</span> <span class="identifier">obs</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">obs</span><span class="special">,</span> <span class="comment">// not null</span>
<span class="keyword">not</span> <span class="identifier">attached</span><span class="special">(</span><span class="identifier">obs</span><span class="special">)</span> <span class="comment">// not already attached</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_observers</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">observers</span><span class="special">(),</span>
<span class="identifier">attached</span><span class="special">(</span><span class="identifier">obs</span><span class="special">),</span> <span class="comment">// attached</span>
<span class="identifier">other_observers_unchanged</span><span class="special">(</span><span class="identifier">old_observers</span><span class="special">,</span> <span class="identifier">observers</span><span class="special">(),</span> <span class="identifier">obs</span><span class="special">),</span>
<span class="comment">// others not changed (frame rule)</span>
<span class="identifier">requires</span> <span class="identifier">O_N</span> <span class="special">&lt;=</span> <span class="identifier">COMPLEXITY_MAX</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">observers_</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">obs</span><span class="special">);</span>
<span class="special">}</span>
<span class="comment">// Queries.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// All observers attached to this subject.</span>
<span class="keyword">protected</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;)</span> <span class="special">(</span><span class="identifier">observers</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Create list of pointers to const observers.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">observer</span><span class="special">*&gt;</span> <span class="identifier">obs</span><span class="special">;</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span><span class="special">*&gt;::</span><span class="identifier">const_iterator</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="identifier">observers_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">observers_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">obs</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(*</span><span class="identifier">i</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">return</span> <span class="identifier">obs</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Update all attached observers.</span>
<span class="keyword">protected</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">notify</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">all_observers_updated</span><span class="special">(</span><span class="identifier">observers</span><span class="special">())</span> <span class="special">)</span> <span class="comment">// all updated</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span><span class="special">*&gt;::</span><span class="identifier">iterator</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="identifier">observers_</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">observers_</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="special">{</span>
<span class="comment">// Class invariant ensures no null pointers in observers but</span>
<span class="comment">// class invariants not checked for non-public members so check.</span>
<span class="identifier">CONTRACT_BLOCK_INVARIANT</span><span class="special">(</span> <span class="keyword">const</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="special">*</span><span class="identifier">i</span> <span class="special">)</span> <span class="comment">// pointer not null</span>
<span class="special">(*</span><span class="identifier">i</span><span class="special">)-&gt;</span><span class="identifier">update</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="comment">// Contract helpers.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">static</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">all_observers_valid</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">observers</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;::</span><span class="identifier">const_iterator</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="identifier">observers</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">observers</span><span class="special">.</span><span class="identifier">end</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">if</span><span class="special">(!(*</span><span class="identifier">i</span><span class="special">))</span> <span class="keyword">return</span> <span class="keyword">false</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>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">other_observers_unchanged</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">old</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">now</span><span class="special">,</span>
<span class="special">(</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*)</span> <span class="identifier">obs</span>
<span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">obs</span> <span class="special">)</span> <span class="comment">// not null</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="identifier">remaining</span> <span class="special">=</span> <span class="identifier">now</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">remove</span><span class="special">(</span><span class="identifier">remaining</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">remaining</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">obs</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;::</span><span class="identifier">const_iterator</span>
<span class="identifier">remaining_it</span> <span class="special">=</span> <span class="identifier">remaining</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;::</span><span class="identifier">const_iterator</span> <span class="identifier">old_it</span> <span class="special">=</span> <span class="identifier">old</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span>
<span class="keyword">while</span><span class="special">(</span><span class="identifier">remaining</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">!=</span> <span class="identifier">remaining_it</span> <span class="special">&amp;&amp;</span> <span class="identifier">old</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span> <span class="special">!=</span> <span class="identifier">old_it</span><span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(*</span><span class="identifier">remaining_it</span> <span class="special">!=</span> <span class="special">*</span><span class="identifier">old_it</span><span class="special">)</span> <span class="keyword">return</span> <span class="keyword">false</span><span class="special">;</span>
<span class="special">++</span><span class="identifier">remaining_it</span><span class="special">;</span>
<span class="special">++</span><span class="identifier">old_it</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>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">all_observers_updated</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">observers</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span> <span class="keyword">const</span><span class="special">*&gt;::</span><span class="identifier">const_iterator</span>
<span class="identifier">i</span> <span class="special">=</span> <span class="identifier">observers</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">observers</span><span class="special">.</span><span class="identifier">end</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">if</span><span class="special">(!(*</span><span class="identifier">i</span><span class="special">))</span> <span class="keyword">return</span> <span class="keyword">false</span><span class="special">;</span>
<span class="keyword">if</span><span class="special">(!(*</span><span class="identifier">i</span><span class="special">)-&gt;</span><span class="identifier">up_to_date_with_subject</span><span class="special">())</span> <span class="keyword">return</span> <span class="keyword">false</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>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">observer</span><span class="special">*&gt;</span> <span class="identifier">observers_</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: observer_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"observer/observer.hpp"</span>
<span class="preprocessor">#include</span> <span class="string">"observer/subject.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">state_check</span><span class="special">;</span> <span class="comment">// For unit testing.</span>
<span class="keyword">class</span> <span class="identifier">concrete_subject</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">subject</span> <span class="comment">// Implement an actual subject.</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">state</span><span class="special">;</span> <span class="comment">// Some state being observed.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">concrete_subject</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="special">:</span> <span class="identifier">state_</span><span class="special">()</span> <span class="special">{}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">set_state</span> <span class="special">(</span><span class="identifier">state</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">the_state</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">state_</span> <span class="special">=</span> <span class="identifier">the_state</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">state_</span> <span class="special">==</span> <span class="identifier">state_check</span><span class="special">);</span>
<span class="identifier">notify</span><span class="special">();</span> <span class="comment">// Notify observers.</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">state</span> <span class="identifier">get_state</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">state_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">state</span> <span class="identifier">state_</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Implement of actual observer.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">concrete_observer</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">observer</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create concrete observer.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">concrete_observer</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">concrete_subject</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">the_subject</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">subject_</span><span class="special">(</span><span class="identifier">the_subject</span><span class="special">),</span> <span class="identifier">observed_state_</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Implement base virtual functions.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">up_to_date_with_subject</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="identifier">override</span> <span class="identifier">final</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="comment">// For simplicity, always up-to-date.</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">update</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span> <span class="identifier">final</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">observed_state_</span> <span class="special">=</span> <span class="identifier">subject_</span><span class="special">.</span><span class="identifier">get_state</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">observed_state_</span> <span class="special">==</span> <span class="identifier">state_check</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">concrete_subject</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">subject_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">concrete_subject</span><span class="special">::</span><span class="identifier">state</span> <span class="identifier">observed_state_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">concrete_subject</span> <span class="identifier">sbj</span><span class="special">;</span>
<span class="identifier">concrete_observer</span> <span class="identifier">ob</span><span class="special">(</span><span class="identifier">sbj</span><span class="special">);</span>
<span class="identifier">sbj</span><span class="special">.</span><span class="identifier">attach</span><span class="special">(&amp;</span><span class="identifier">ob</span><span class="special">);</span>
<span class="identifier">sbj</span><span class="special">.</span><span class="identifier">set_state</span><span class="special">(</span><span class="identifier">state_check</span> <span class="special">=</span> <span class="number">123</span><span class="special">);</span>
<span class="identifier">sbj</span><span class="special">.</span><span class="identifier">set_state</span><span class="special">(</span><span class="identifier">state_check</span> <span class="special">=</span> <span class="number">456</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Mitchell02] Counter: Subcontracting and virtual specifiers (final, override, new, and pure virtual)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__mitchell02___counter__subcontracting_and_virtual_specifiers__final__override__new__and_pure_virtual_"></a><a class="link" href="#contract__.examples.__mitchell02___counter__subcontracting_and_virtual_specifiers__final__override__new__and_pure_virtual_" title="[Mitchell02] Counter: Subcontracting and virtual specifiers (final, override, new, and pure virtual)">[Mitchell02]
Counter: Subcontracting and virtual specifiers (final, override, new, and pure
virtual)</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: counter/push_button.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">PUSH_BUTTON_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">PUSH_BUTTON_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Basic button.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">push_button</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no invariant</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create an enabled button.</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">push_button</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">enabled</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// enabled</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">enabled_</span><span class="special">(</span><span class="keyword">true</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy button.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">push_button</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Queries.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// If button enabled.</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">enabled</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">enabled_</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Enable this button.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">enable</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">enabled</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// enabled</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">enabled_</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Disable this button.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">disable</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">enabled</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// disabled</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">enabled_</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Invoked externally when this button is clicked.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">on_bn_clicked</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">new</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">enabled</span><span class="special">()</span> <span class="special">)</span> <span class="comment">// enabled</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Contract for pure virtual function.</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">bool</span> <span class="identifier">enabled_</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: counter/decrement_button.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">DECREMENT_BUTTON_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">DECREMENT_BUTTON_HPP_</span>
<span class="preprocessor">#include</span> <span class="string">"push_button.hpp"</span>
<span class="preprocessor">#include</span> <span class="string">"counter.hpp"</span>
<span class="preprocessor">#include</span> <span class="string">"../observer/observer.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Button that decrements counter.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">decrement_button</span><span class="special">)</span> <span class="identifier">final</span> <span class="comment">// Contract for final class.</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">push_button</span><span class="special">,</span> <span class="keyword">protected</span> <span class="identifier">observer</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no invariant</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create button associated with given counter.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">decrement_button</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">&amp;)</span> <span class="identifier">the_counter</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="comment">// enabled iff positive value</span>
<span class="identifier">enabled</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">the_counter</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">)</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">counter_ref_</span><span class="special">(</span><span class="identifier">the_counter</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">attach</span><span class="special">(</span><span class="keyword">this</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy button.</span>
<span class="keyword">public</span> <span class="special">(~</span><span class="identifier">decrement_button</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">on_bn_clicked</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">value</span><span class="special">(),</span>
<span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">-</span> <span class="number">1</span> <span class="comment">// counter decremented</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">decrement</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">up_to_date_with_subject</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="identifier">override</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="comment">// For simplicity, always up-to-date.</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">update</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="comment">// enabled if positive value</span>
<span class="identifier">enabled</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&gt;</span> <span class="number">0</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span> <span class="identifier">disable</span><span class="special">();</span>
<span class="keyword">else</span> <span class="identifier">enable</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">counter</span><span class="special">&amp;</span> <span class="identifier">counter_ref_</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: counter/counter.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">COUNTER_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">COUNTER_HPP_</span>
<span class="preprocessor">#include</span> <span class="string">"../observer/subject.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Positive integer counter.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">subject</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no invariants</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Construct counter with specified value.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="identifier">a_value</span><span class="special">,</span> <span class="keyword">default</span> <span class="number">10</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">a_value</span> <span class="special">)</span> <span class="comment">// value set</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">value_</span><span class="special">(</span><span class="identifier">a_value</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy counter.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">counter</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// Queries.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Current counter value.</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">value</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">}</span>
<span class="comment">// Commands.</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Decrement counter value.</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">decrement</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_value</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">value</span><span class="special">(),</span>
<span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_value</span> <span class="special">-</span> <span class="number">1</span> <span class="comment">// decremented</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="special">--</span><span class="identifier">value_</span><span class="special">;</span>
<span class="identifier">notify</span><span class="special">();</span> <span class="comment">// Notifies all attached observers.</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">value_</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: counter_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"counter/counter.hpp"</span>
<span class="preprocessor">#include</span> <span class="string">"counter/decrement_button.hpp"</span>
<span class="preprocessor">#include</span> <span class="string">"observer/observer.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">counter_check</span><span class="special">;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Show current value of associated counter.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">view_of_counter</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">private</span> <span class="identifier">observer</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no invariant</span>
<span class="comment">// Creation.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Create viewer associated with given counter.</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">view_of_counter</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">counter</span><span class="special">&amp;)</span> <span class="identifier">the_counter</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">counter_ref_</span><span class="special">(</span><span class="identifier">the_counter</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">attach</span><span class="special">(</span><span class="keyword">this</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">counter_check</span><span class="special">);</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span> <span class="comment">// Destroy viewer.</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">view_of_counter</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">up_to_date_with_subject</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="identifier">override</span> <span class="identifier">final</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="comment">// For simplicity, always up-to-date.</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">update</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span> <span class="identifier">final</span> <span class="comment">// Contract final func.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">counter_ref_</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">counter_check</span><span class="special">);</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">counter</span><span class="special">&amp;</span> <span class="identifier">counter_ref_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">counter</span> <span class="identifier">count</span><span class="special">(</span><span class="identifier">counter_check</span> <span class="special">=</span> <span class="number">1</span><span class="special">);</span>
<span class="identifier">view_of_counter</span> <span class="identifier">view</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="identifier">decrement_button</span> <span class="identifier">decrement</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">decrement</span><span class="special">.</span><span class="identifier">enabled</span><span class="special">());</span>
<span class="identifier">counter_check</span><span class="special">--;</span>
<span class="identifier">decrement</span><span class="special">.</span><span class="identifier">on_bn_clicked</span><span class="special">();</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">decrement</span><span class="special">.</span><span class="identifier">enabled</span><span class="special">());</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Stroustrup97] String: Throw when contract is broken"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__stroustrup97___string__throw_when_contract_is_broken"></a><a class="link" href="#contract__.examples.__stroustrup97___string__throw_when_contract_is_broken" title="[Stroustrup97] String: Throw when contract is broken">[Stroustrup97]
String: Throw when contract is broken</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: string.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">STRING_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">STRING_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cstring</span><span class="special">&gt;</span>
<span class="comment">// Adapted from an example presented in [Stroustrup1997] to illustrate</span>
<span class="comment">// importance of class invariants. Simple preconditions were added where it</span>
<span class="comment">// made sense. This should be compiled with postconditions checking turned off</span>
<span class="comment">// (define the `CONTRACT_CONFIG_NO_POSTCONDITIONS` macro) because</span>
<span class="comment">// postconditions are deliberately not used.</span>
<span class="comment">// See [Stroustrup1997] for a discussion on the importance of class invariants,</span>
<span class="comment">// and on pros and cons of using pre and post conditions.</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">string</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span>
<span class="comment">// It would be better to assert conditions separately so to generate</span>
<span class="comment">// more informative error in case they fail.</span>
<span class="identifier">chars_</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">invariant_error</span><span class="special">(),</span>
<span class="identifier">size_</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">invariant_error</span><span class="special">(),</span>
<span class="identifier">too_large</span> <span class="special">&gt;=</span> <span class="identifier">size_</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">invariant_error</span><span class="special">(),</span>
<span class="identifier">chars_</span><span class="special">[</span><span class="identifier">size_</span><span class="special">]</span> <span class="special">==</span> <span class="char">'\0'</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">invariant_error</span><span class="special">()</span>
<span class="special">)</span>
<span class="comment">// Broken contracts throw user defined exceptions.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">class</span> <span class="identifier">range_error</span> <span class="special">{};</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">class</span> <span class="identifier">invariant_error</span> <span class="special">{};</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">class</span> <span class="identifier">null_error</span> <span class="special">{};</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">class</span> <span class="identifier">too_large_error</span> <span class="special">{};</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">enum</span> <span class="special">{</span> <span class="identifier">too_large</span> <span class="special">=</span> <span class="number">16000</span> <span class="special">};</span> <span class="comment">// Length limit.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*)</span> <span class="identifier">chars</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">chars</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">null_error</span><span class="special">(),</span>
<span class="identifier">strlen</span><span class="special">(</span><span class="identifier">chars</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="identifier">too_large</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">too_large_error</span><span class="special">()</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span> <span class="comment">// Deferred body definition.</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;)</span> <span class="identifier">other</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(~</span><span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="keyword">char</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">index</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">range_error</span><span class="special">(),</span>
<span class="identifier">size_</span> <span class="special">&gt;</span> <span class="identifier">index</span> <span class="special">?</span> <span class="keyword">true</span> <span class="special">:</span> <span class="keyword">throw</span> <span class="identifier">range_error</span><span class="special">()</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">size</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span> <span class="comment">// Not public so it does not check class invariants.</span>
<span class="keyword">private</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">init</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*)</span> <span class="identifier">q</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">size_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">chars_</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: string.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"string.hpp"</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">chars</span> <span class="special">)</span>
<span class="special">{</span> <span class="identifier">init</span><span class="special">(</span><span class="identifier">chars</span><span class="special">);</span> <span class="special">}</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">other</span> <span class="special">)</span>
<span class="special">{</span> <span class="identifier">init</span><span class="special">(</span><span class="identifier">other</span><span class="special">.</span><span class="identifier">chars_</span><span class="special">);</span> <span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_BODY</span><span class="special">(</span><span class="identifier">string</span><span class="special">,</span> <span class="special">~</span><span class="identifier">string</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span> <span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">chars_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">char</span><span class="special">&amp;</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">))</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="special">{</span> <span class="keyword">return</span> <span class="identifier">chars_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">size</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">size_</span><span class="special">;</span> <span class="special">}</span>
<span class="keyword">void</span> <span class="identifier">CONTRACT_MEMBER_BODY</span><span class="special">(</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">init</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">chars</span> <span class="special">)</span> <span class="special">{</span>
<span class="identifier">size_</span> <span class="special">=</span> <span class="identifier">strlen</span><span class="special">(</span><span class="identifier">chars</span><span class="special">);</span>
<span class="identifier">chars_</span> <span class="special">=</span> <span class="keyword">new</span> <span class="keyword">char</span><span class="special">[</span><span class="identifier">size_</span> <span class="special">+</span> <span class="number">1</span><span class="special">];</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">size_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">chars_</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">chars</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="identifier">chars_</span><span class="special">[</span><span class="identifier">size_</span><span class="special">]</span> <span class="special">=</span> <span class="char">'\0'</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
</p><p>
</p><pre class="programlisting"><span class="comment">// File: string_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"string.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="comment">// Handler that re-throws contract broken exceptions instead of terminating.</span>
<span class="keyword">void</span> <span class="identifier">throwing_handler</span> <span class="special">(</span> <span class="identifier">contract</span><span class="special">::</span><span class="identifier">from</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">context</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">if</span><span class="special">(</span><span class="identifier">context</span> <span class="special">==</span> <span class="identifier">contract</span><span class="special">::</span><span class="identifier">FROM_DESTRUCTOR</span><span class="special">)</span> <span class="special">{</span>
<span class="comment">// Destructor cannot throw for STL exception safety (ignore error).</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">clog</span> <span class="special">&lt;&lt;</span> <span class="string">"Ignored destructor contract failure"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span>
<span class="comment">// Failure handlers always called with active an exception.</span>
<span class="keyword">throw</span><span class="special">;</span> <span class="comment">// Re-throw active exception thrown by precondition.</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="comment">// Setup all contract failure handlers to throw (instead of terminate).</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">set_precondition_broken</span><span class="special">(&amp;</span><span class="identifier">throwing_handler</span><span class="special">);</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">set_postcondition_broken</span><span class="special">(&amp;</span><span class="identifier">throwing_handler</span><span class="special">);</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">set_class_invariant_broken</span><span class="special">(&amp;</span><span class="identifier">throwing_handler</span><span class="special">);</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">set_block_invariant_broken</span><span class="special">(&amp;</span><span class="identifier">throwing_handler</span><span class="special">);</span>
<span class="identifier">contract</span><span class="special">::</span><span class="identifier">set_loop_variant_broken</span><span class="special">(&amp;</span><span class="identifier">throwing_handler</span><span class="special">);</span>
<span class="identifier">string</span> <span class="identifier">s</span><span class="special">(</span><span class="string">"abc"</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="char">'a'</span><span class="special">);</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">CONTRACT_CONFIG_NO_PRECONDITIONS</span>
<span class="keyword">bool</span> <span class="identifier">pass</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
<span class="keyword">try</span> <span class="special">{</span> <span class="identifier">s</span><span class="special">[</span><span class="number">3</span><span class="special">];</span> <span class="special">}</span> <span class="comment">// Out of range.</span>
<span class="keyword">catch</span><span class="special">(</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">range_error</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">pass</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span> <span class="special">}</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">pass</span><span class="special">);</span>
<span class="preprocessor">#endif</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Cline90] Vector: Comparison with A++ proposed syntax"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__cline90___vector__comparison_with_a___proposed_syntax"></a><a class="link" href="#contract__.examples.__cline90___vector__comparison_with_a___proposed_syntax" title="[Cline90] Vector: Comparison with A++ proposed syntax">[Cline90]
Vector: Comparison with A++ proposed syntax</a></h3></div></div></div><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
This Library (C++03)
</p>
</th><th>
<p>
A++ Proposal (not part of C++)
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: vector.hpp</span>
<span class="preprocessor">#ifndef</span> <span class="identifier">VECTOR_HPP_</span>
<span class="preprocessor">#define</span> <span class="identifier">VECTOR_HPP_</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">vector</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// NOTE: Incomplete set of assertions addressing only `size`.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">count</span><span class="special">,</span> <span class="keyword">default</span> <span class="number">10</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">data_</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">count</span><span class="special">]),</span> <span class="identifier">size_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">size_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">data_</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">size</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="comment">// postcondition: Result non-negative checked by class invariant</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">size_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">resize</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</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">T</span><span class="special">*</span> <span class="identifier">slice</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">count</span><span class="special">];</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">count</span> <span class="special">&amp;&amp;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">size_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">slice</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">data_</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="identifier">data_</span> <span class="special">=</span> <span class="identifier">slice</span><span class="special">;</span>
<span class="identifier">size_</span> <span class="special">=</span> <span class="identifier">count</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span><span class="special">&amp;)</span> <span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">index</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">,</span>
<span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">()</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">data_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">size_</span><span class="special">;</span>
<span class="special">};</span>
<span class="preprocessor">#endif</span> <span class="comment">// #include guard</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: vector_app.hpp</span>
<span class="comment">// Extra spaces, newlines, etc used to align text with this library code.</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">vector</span>
<span class="special">{</span>
<span class="identifier">legal</span><span class="special">:</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Class invariants (legal).</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">explicit</span> <span class="identifier">vector</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">count</span> <span class="special">=</span> <span class="number">10</span> <span class="special">)</span>
<span class="special">:</span> <span class="identifier">data_</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">count</span><span class="special">]),</span> <span class="identifier">size_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">size_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">data_</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">();</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">vector</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">size</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">size_</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">void</span> <span class="identifier">resize</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">T</span><span class="special">*</span> <span class="identifier">slice</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">count</span><span class="special">];</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">count</span> <span class="special">&amp;&amp;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">size_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">slice</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">data_</span><span class="special">[</span><span class="identifier">i</span><span class="special">];</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="identifier">data_</span> <span class="special">=</span> <span class="identifier">slice</span><span class="special">;</span>
<span class="identifier">size_</span> <span class="special">=</span> <span class="identifier">count</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">public</span><span class="special">:</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">[]</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">index</span> <span class="special">)</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">data_</span><span class="special">[</span><span class="identifier">index</span><span class="special">];</span>
<span class="special">}</span>
<span class="comment">// Preconditions (require) and postconditions (promise) for each function.</span>
<span class="identifier">axioms</span><span class="special">:</span> <span class="special">[</span> <span class="keyword">int</span> <span class="identifier">count</span><span class="special">;</span> <span class="identifier">require</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">promise</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span> <span class="special">]</span>
<span class="identifier">vector</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="identifier">axioms</span><span class="special">:</span> <span class="special">[</span> <span class="keyword">int</span> <span class="identifier">count</span><span class="special">;</span> <span class="identifier">require</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">promise</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span> <span class="special">]</span>
<span class="identifier">resize</span><span class="special">(</span><span class="identifier">count</span><span class="special">);</span>
<span class="identifier">axioms</span><span class="special">:</span> <span class="special">[</span> <span class="keyword">int</span> <span class="identifier">index</span><span class="special">;</span> <span class="identifier">require</span> <span class="identifier">index</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">&amp;&amp;</span> <span class="identifier">index</span> <span class="special">&lt;</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">]</span>
<span class="special">(*</span><span class="keyword">this</span><span class="special">)[</span><span class="identifier">x</span><span class="special">];</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">size_</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p>
</td></tr><tr><td>
<p>
</p><pre class="programlisting"><span class="comment">// File: vector_main.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"vector.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">(</span><span class="number">3</span><span class="special">);</span> <span class="comment">// Also set all elements to 0.0.</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="number">123</span><span class="special">;</span>
<span class="identifier">v</span><span class="special">.</span><span class="identifier">resize</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">v</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">2</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p>
</td><td>
</td></tr></tbody></table></div></div><div class="section" title="[Cline90] Stack: Function-Try blocks and exception specifications"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__cline90___stack__function_try_blocks_and_exception_specifications"></a><a class="link" href="#contract__.examples.__cline90___stack__function_try_blocks_and_exception_specifications" title="[Cline90] Stack: Function-Try blocks and exception specifications">[Cline90]
Stack: Function-Try blocks and exception specifications</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: stack.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">identity_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">exception</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="keyword">new</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">utility</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">stack</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// NOTE: Incomplete set of assertions addressing only `empty` and `full`.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">struct</span> <span class="identifier">out_of_memory</span> <span class="special">{};</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">struct</span> <span class="identifier">error</span> <span class="special">{};</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">stack</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">capacity</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">capacity</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">empty</span><span class="special">(),</span>
<span class="identifier">full</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">capacity</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span>
<span class="special">)</span>
<span class="comment">// Function-Try blocks are programmed within the macros only for</span>
<span class="comment">// constructors with member initializers otherwise they are</span>
<span class="comment">// programmed with the body definition and outside the macros.</span>
<span class="keyword">try</span> <span class="identifier">initialize</span><span class="special">(</span> <span class="comment">// Try-block for constructor initializers and body.</span>
<span class="identifier">data_</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">capacity</span><span class="special">]),</span>
<span class="identifier">capacity_</span><span class="special">(</span><span class="identifier">capacity</span><span class="special">),</span>
<span class="identifier">size_</span><span class="special">(</span><span class="number">0</span><span class="special">)</span>
<span class="special">)</span> <span class="keyword">catch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"out of memory for "</span> <span class="special">&lt;&lt;</span> <span class="identifier">capacity</span> <span class="special">&lt;&lt;</span> <span class="string">"-stack: "</span> <span class="special">&lt;&lt;</span>
<span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span> <span class="identifier">out_of_memory</span><span class="special">();</span>
<span class="comment">// Unfortunately, cannot wrap exception type commas with extra</span>
<span class="comment">// parenthesis (because symbol `...` used to catch-all) but</span>
<span class="comment">// `BOOST_IDENTITY_TYPE` can be used.</span>
<span class="special">)</span> <span class="keyword">catch</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*&gt;&amp;))</span> <span class="identifier">e</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"error number "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">" for "</span> <span class="special">&lt;&lt;</span>
<span class="identifier">capacity</span> <span class="special">&lt;&lt;</span> <span class="string">"-stack: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span> <span class="identifier">error</span><span class="special">();</span>
<span class="special">)</span> <span class="keyword">catch</span><span class="special">(...)</span> <span class="special">(</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"unknown error for "</span> <span class="special">&lt;&lt;</span> <span class="identifier">capacity</span> <span class="special">&lt;&lt;</span> <span class="string">"-stack"</span> <span class="special">&lt;&lt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span><span class="special">;</span> <span class="comment">// Re-throw exception.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">capacity_</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">data_</span><span class="special">[</span><span class="identifier">i</span><span class="special">]</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">stack</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span>
<span class="preprocessor">#if</span> <span class="special">!</span><span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_MSVC</span><span class="special">)</span> <span class="comment">// MSVC supports only constructor-try blocks.</span>
<span class="keyword">try</span> <span class="special">{</span> <span class="comment">// Function-try block (outside the macro).</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="special">}</span> <span class="keyword">catch</span><span class="special">(...)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"error for stack destruction, terminating"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span><span class="special">();</span> <span class="comment">// Destructor should never throw.</span>
<span class="special">}</span>
<span class="preprocessor">#else</span> <span class="comment">// MSVC</span>
<span class="special">{</span>
<span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// MSVC</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">size_</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">full</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">size_</span> <span class="special">==</span> <span class="identifier">capacity_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push</span><span class="special">)</span> <span class="special">(</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="preprocessor">#if</span> <span class="special">!</span><span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_MSVC</span><span class="special">)</span> <span class="comment">// MSVC only supports throw( void ) exception spec.</span>
<span class="keyword">throw</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">,</span> <span class="identifier">error</span> <span class="special">)</span> <span class="comment">// Ex spec.</span>
<span class="preprocessor">#endif</span> <span class="comment">// MSVC</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">full</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span>
<span class="preprocessor">#if</span> <span class="special">!</span><span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_MSVC</span><span class="special">)</span> <span class="comment">// MSVC supports only constructor-try blocks.</span>
<span class="keyword">try</span>
<span class="preprocessor">#endif</span> <span class="comment">// MSVC</span>
<span class="special">{</span> <span class="comment">// Function-Try block (outside the macro).</span>
<span class="identifier">data_</span><span class="special">[</span><span class="identifier">size_</span><span class="special">++]</span> <span class="special">=</span> <span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="preprocessor">#if</span> <span class="special">!</span><span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_MSVC</span><span class="special">)</span> <span class="comment">// MSVC supports only constructor-try blocks.</span>
<span class="keyword">catch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"error for "</span> <span class="special">&lt;&lt;</span> <span class="identifier">capacity_</span> <span class="special">&lt;&lt;</span> <span class="string">"-stack: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span><span class="special">;</span> <span class="comment">// Re-throw STL exception.</span>
<span class="special">}</span> <span class="keyword">catch</span><span class="special">(...)</span> <span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"unknown error for "</span> <span class="special">&lt;&lt;</span> <span class="identifier">capacity_</span> <span class="special">&lt;&lt;</span> <span class="string">"-stack"</span> <span class="special">&lt;&lt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span> <span class="identifier">error</span><span class="special">();</span>
<span class="special">}</span>
<span class="preprocessor">#endif</span> <span class="comment">// MSVC</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">pop</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">full</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">data_</span><span class="special">[--</span><span class="identifier">size_</span><span class="special">];</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">data_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">capacity_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">size_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">stack</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">s</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">push</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">pop</span><span class="special">()</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Cline90] Vector-Stack: Subcontracting from Abstract Data Type (ADT)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__cline90___vector_stack__subcontracting_from_abstract_data_type__adt_"></a><a class="link" href="#contract__.examples.__cline90___vector_stack__subcontracting_from_abstract_data_type__adt_" title="[Cline90] Vector-Stack: Subcontracting from Abstract Data Type (ADT)">[Cline90]
Vector-Stack: Subcontracting from Abstract Data Type (ADT)</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: vstack.cpp</span>
<span class="preprocessor">#include</span> <span class="string">"vector.hpp"</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Stack Abstract Data Type (ADT).</span>
<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="special">(</span><span class="identifier">stack_adt</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// NOTE: Incomplete set of assertions addressing only empty/full issues.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="comment">// no invariants</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">stack_adt</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="comment">// postcondition:</span>
<span class="comment">// empty (cannot be checked because empty's postcondition uses</span>
<span class="comment">// length which is pure virtual during construction)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(~</span><span class="identifier">stack_adt</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">full</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">length</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">capacity</span><span class="special">())</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">length</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">capacity</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">bool</span> <span class="special">(</span><span class="identifier">empty</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">length</span><span class="special">()</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="keyword">return</span> <span class="identifier">length</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">length</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">capacity</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push</span><span class="special">)</span> <span class="special">(</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">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">full</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Contract for pure virtual function.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">pop</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">not</span> <span class="identifier">full</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">clear</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">empty</span><span class="special">()</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span> <span class="comment">// Vector-based stack.</span>
<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="special">(</span><span class="identifier">vstack</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">stack_adt</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">length</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">0</span><span class="special">,</span>
<span class="identifier">length</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">capacity</span><span class="special">()</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vstack</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">count</span><span class="special">,</span> <span class="keyword">default</span> <span class="number">10</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">length</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vect_</span><span class="special">(</span><span class="identifier">count</span><span class="special">),</span> <span class="identifier">length_</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// OK, after preconditions.</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">vstack</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="comment">// NOTE: All following inherit contracts from `stack_adt`.</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">length</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="identifier">override</span> <span class="identifier">final</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">length_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">capacity</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vect_</span><span class="special">.</span><span class="identifier">size</span><span class="special">();</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push</span><span class="special">)</span> <span class="special">(</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">override</span> <span class="identifier">final</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vect_</span><span class="special">[</span><span class="identifier">length_</span><span class="special">++]</span> <span class="special">=</span> <span class="identifier">value</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">(</span><span class="identifier">pop</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span> <span class="identifier">final</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vect_</span><span class="special">[--</span><span class="identifier">length_</span><span class="special">];</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">clear</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="identifier">override</span> <span class="identifier">final</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">length_</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">vect_</span><span class="special">;</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">length_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">vstack</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">s</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">==</span> <span class="number">3</span><span class="special">);</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">push</span><span class="special">(</span><span class="number">123</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">length</span><span class="special">()</span> <span class="special">==</span> <span class="number">1</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">pop</span><span class="special">()</span> <span class="special">==</span> <span class="number">123</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div><div class="section" title="[Cline90] Calendar: A very simple calendar"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.examples.__cline90___calendar__a_very_simple_calendar"></a><a class="link" href="#contract__.examples.__cline90___calendar__a_very_simple_calendar" title="[Cline90] Calendar: A very simple calendar">[Cline90]
Calendar: A very simple calendar</a></h3></div></div></div><p>
</p><pre class="programlisting"><span class="comment">// File: calendar.cpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">contract</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">detail</span><span class="special">/</span><span class="identifier">lightweight_test</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">calendar</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT</span><span class="special">(</span>
<span class="identifier">month</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">month</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="number">12</span><span class="special">,</span>
<span class="identifier">date</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">date</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">days_in</span><span class="special">(</span><span class="identifier">month</span><span class="special">())</span>
<span class="special">)</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">calendar</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">month</span><span class="special">()</span> <span class="special">==</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">date</span><span class="special">()</span> <span class="special">==</span> <span class="number">31</span> <span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">month_</span><span class="special">(</span><span class="number">1</span><span class="special">),</span> <span class="identifier">date_</span><span class="special">(</span><span class="number">31</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">calendar</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">month</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">month_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">date</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">date_</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">reset</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">new_month</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">new_month</span> <span class="special">&gt;=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">new_month</span> <span class="special">&lt;=</span> <span class="number">12</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">month</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">new_month</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">month_</span> <span class="special">=</span> <span class="identifier">new_month</span><span class="special">;</span>
<span class="special">}</span>
<span class="identifier">CONTRACT_FUNCTION</span><span class="special">(</span>
<span class="keyword">private</span> <span class="keyword">static</span> <span class="keyword">int</span> <span class="special">(</span><span class="identifier">days_in</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">month</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">month</span> <span class="special">&gt;=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">month</span> <span class="special">&lt;=</span> <span class="number">12</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&gt;=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">result</span> <span class="special">&lt;=</span> <span class="number">31</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="number">31</span><span class="special">;</span> <span class="comment">// For simplicity, assume all months have 31 days.</span>
<span class="special">}</span>
<span class="keyword">private</span><span class="special">:</span> <span class="keyword">int</span> <span class="identifier">month_</span><span class="special">,</span> <span class="identifier">date_</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">calendar</span> <span class="identifier">c</span><span class="special">;</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">date</span><span class="special">()</span> <span class="special">==</span> <span class="number">31</span><span class="special">);</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">month</span><span class="special">()</span> <span class="special">==</span> <span class="number">1</span><span class="special">);</span>
<span class="identifier">c</span><span class="special">.</span><span class="identifier">reset</span><span class="special">(</span><span class="number">8</span><span class="special">);</span> <span class="comment">// Set month to August.</span>
<span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">month</span><span class="special">()</span> <span class="special">==</span> <span class="number">8</span><span class="special">);</span>
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
<span class="special">}</span>
</pre><p>
</p></div></div><div class="section" title="Grammar"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.grammar"></a><a class="link" href="#contract__.grammar" title="Grammar">Grammar</a></h2></div></div></div><div class="blockquote"><blockquote class="blockquote"><p>
<span class="emphasis"><em><span class="quote">&#8220;<span class="quote">Almost every macro demonstrates a flaw in the programming
language, in the program, or in the programmer.</span>&#8221;</span></em></span>
</p></blockquote></div><div class="blockquote"><blockquote class="blockquote"><p>
<span class="emphasis"><em>--Stroustrup (see <a class="link" href="#Stroustrup97_anchor">[Stroustrup97]</a>
page 160)</em></span>
</p></blockquote></div><p>
This library uses macros to overcome a limitation of C++, namely the fact that
the core language does not support preconditions, postconditions, class invariants,
old values, and subcontracting. This section lists the complete grammar of
the syntax used by this library macros.
</p><a name="syntax_error_warning_anchor"></a><div class="warning" title="Warning"><table border="0" summary="Warning"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../doc/src/images/warning.png"></td><th align="left">Warning</th></tr><tr><td align="left" valign="top"><p>
In general, an error in programming this library syntax will generate cryptic
compiler errors (often exposing internal code from this library and from
<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/preprocessor" target="_top">Boost.Preprocessor</a>).
<sup>[<a name="contract__.grammar.f0" href="#ftn.contract__.grammar.f0" class="footnote">68</a>]</sup>
</p><p>
There are intrinsic limitations on the amount of error checking that can
be implemented by this library because it uses the preprocessor to parse
its syntax (e.g., there is no way the preprocessor can gracefully detect
and report unbalanced round parenthesis <code class="computeroutput"><span class="special">(</span>
<span class="special">...</span> <span class="comment">/* missing closing
parenthesis here */</span></code> or an invalid concatenation symbol <code class="computeroutput"><span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">xyz</span><span class="special">,</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">)</span></code>). In addition, for a given macro all compiler
error messages report the same line number (because macros always expand
on a single line) so line numbers are not very useful in identifying syntactic
errors.
</p><p>
While the preprocessor imposes limits on the error checking that can be implemented,
the current version of this library does not focus on providing the best
possible syntax error messages (this will be the focus of future releases,
see also <a class="ulink" href="https://sourceforge.net/apps/trac/contractpp/ticket/44" target="_top">Ticket
44</a>).
</p></td></tr></table></div><p>
The best way to resolve syntactic errors is for programmers to inspect the
code <span class="quote">&#8220;<span class="quote">by eye</span>&#8221;</span> instead of trying to make sense of the compiler
errors. This section is very useful for programmers to make sure that they
are using the syntax correctly.
</p><div class="section" title="Preprocessor DSEL"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.preprocessor_dsel"></a><a class="link" href="#contract__.grammar.preprocessor_dsel" title="Preprocessor DSEL">Preprocessor DSEL</a></h3></div></div></div><p>
The syntax used by this library macros effectively defies a new language
within C++. More precisely, this library macros define a <a class="ulink" href="http://en.wikipedia.org/wiki/Domain-specific_language" target="_top">Domain-Specific
Embedded Language (DSEL)</a> that replaces the usual C++ syntax for class
and function declarations. This is the <span class="emphasis"><em>Language of Contract++</em></span>
(or <span class="emphasis"><em>LC++</em></span> for short).
</p><p>
In contrast with other DSEL hosted by C++ which are parsed using template
meta-programming (e.g., <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/phoenix" target="_top">Boost.Phoenix</a>),
this library DSEL is parsed <span class="quote">&#8220;<span class="quote">one meta-programming level higher</span>&#8221;</span>
using preprocessor meta-programming. Using both processor meta-programming
and template meta-programming allows this library to implement rules like
this:
</p><pre class="programlisting"><span class="emphasis"><em>if a member function is not public then it does not check the class invariants</em></span>
</pre><p>
This rule cannot be implemented using only template meta-programming because
(at least to the authors' best knowledge) it is not possible to check if
a function is public using template meta-programming introspection techniques.
For example, it is not possible to implement a boolean meta-function like
the following:
</p><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="special">...</span> <span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_public</span> <span class="special">{</span> <span class="special">...</span> <span class="special">};</span> <span class="comment">// Unfortunately, this cannot be implemented.</span>
</pre><p>
Instead a macro can be programmed to parse the following function declarations
and expand to <code class="computeroutput"><span class="number">1</span></code> if and only if
the function is public:
</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">IS_PUBLIC</span><span class="special">(</span><span class="identifier">function_declaration</span><span class="special">)</span> <span class="special">...</span> <span class="comment">// This can be implemented.</span>
<span class="identifier">IS_PUBLIC</span><span class="special">(</span> <span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">f</span><span class="special">)</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="comment">// Expand to 1.</span>
<span class="identifier">IS_PUBLIC</span><span class="special">(</span> <span class="keyword">private</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">g</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="special">)</span> <span class="comment">// Expand to 0.</span>
<span class="identifier">IS_PUBLIC</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">h</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">z</span> <span class="special">)</span> <span class="special">)</span> <span class="comment">// Expand to 0.</span>
</pre><p>
There are more examples of class and function declaration traits (<code class="computeroutput"><span class="keyword">virtual</span></code>, etc) that need to be known to correctly
implement Contract Programming but that cannot be inspected using template
meta-programming. This library macros can instead parse the specified class
and function declarations extracting <span class="emphasis"><em>any</em></span> declaration
trait (if a constructor is <code class="computeroutput"><span class="keyword">explicit</span></code>,
if a member function is <code class="computeroutput"><span class="keyword">virtual</span></code>,
if a base class is <code class="computeroutput"><span class="keyword">protected</span></code>,
if a parameter has a default value, etc).
</p><p>
It should be noted that while the syntax of the DSEL defined by this library
macros is rather extensive and complex, macros always define a DSEL that
is intrinsically different from the core C++ language. For example, consider
the following function-like macro:
</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">F</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</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">int</span><span class="special">(</span><span class="identifier">y</span><span class="special">))</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">X</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Y</span> <span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">f</span> <span class="special">(</span> <span class="identifier">X</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">Y</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">{</span> <span class="keyword">return</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">int</span><span class="special">(</span><span class="identifier">y</span><span class="special">));</span> <span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">F</span><span class="special">(</span> <span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// OK, no syntax error, it prints `-2`.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">f</span><span class="special">(</span> <span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Compiler generates a syntax error.</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre><p>
Note how it is valid to invoke the macro with an empty parameter <code class="computeroutput"><span class="identifier">F</span><span class="special">(</span> <span class="special">,</span>
<span class="number">2</span><span class="special">)</span></code>
while it is syntactically invalid to invoke a function with an empty parameter
<code class="computeroutput"><span class="identifier">f</span><span class="special">(</span>
<span class="special">,</span> <span class="number">2</span><span class="special">)</span></code>. This very simple macro already shows fundamental
differences between the syntax of macros and the syntax of the core language.
</p></div><div class="section" title="Differences with C++ Syntax"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.differences_with_c___syntax"></a><a class="link" href="#contract__.grammar.differences_with_c___syntax" title="Differences with C++ Syntax">Differences
with C++ Syntax</a></h3></div></div></div><p>
The following is a summary of all the differences between the syntax of this
library macros and the usual C++ class and function declaration syntax.
</p><div class="informaltable"><table border="1"><colgroup><col><col><col></colgroup><thead><tr><th>
<p>
Rule
</p>
</th><th>
<p>
Syntactic Element
</p>
</th><th>
<p>
Syntax Differences
</p>
</th></tr></thead><tbody><tr><td>
<p>
1
</p>
</td><td>
<p>
Template Declarations
</p>
</td><td>
<p>
Use round parenthesis <code class="computeroutput"><span class="keyword">template</span><span class="special">(</span> </code><code class="literal"><span class="emphasis"><em>template-parameters</em></span></code><code class="computeroutput">
<span class="special">)</span></code> instead of angular parenthesis
<code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span>
</code><code class="literal"><span class="emphasis"><em>template-parameters</em></span></code><code class="computeroutput">
<span class="special">&gt;</span></code> to declare templates
(note that template instantiations are not template declarations
and they use angular parenthesis as usual).
</p>
</td></tr><tr><td>
<p>
2
</p>
</td><td>
<p>
Template Specializations
</p>
</td><td>
<p>
Use round parenthesis <code class="computeroutput"><span class="special">(</span>
</code><code class="literal"><span class="emphasis"><em>template-specializations</em></span></code><code class="computeroutput">
<span class="special">)</span></code> instead of angular parenthesis
<code class="computeroutput"><span class="special">&lt;</span> </code><code class="literal"><span class="emphasis"><em>template-specializations</em></span></code><code class="computeroutput">
<span class="special">&gt;</span></code> after a class template
name to specify template specialization arguments.
</p>
</td></tr><tr><td>
<p>
3
</p>
</td><td>
<p>
Class, Function, and Operator Names
</p>
</td><td>
<p>
Wrap class and function declaration names within round parenthesis
<code class="computeroutput"><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>class-name</em></span></code><code class="computeroutput"><span class="special">)</span></code> and <code class="computeroutput"><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>function-name</em></span></code><code class="computeroutput"><span class="special">)</span></code>. Use <code class="computeroutput"><span class="keyword">operator</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>symbol</em></span></code><code class="computeroutput"><span class="special">)(</span></code><code class="literal"><span class="emphasis"><em>arbitrary-name</em></span></code><code class="computeroutput"><span class="special">)</span></code> for operators (allowed but not
required for <code class="computeroutput"><span class="keyword">operator</span> <span class="keyword">new</span></code>, <code class="computeroutput"><span class="keyword">operator</span>
<span class="keyword">delete</span></code>, and implicit type
conversion operators for fundamental types with no symbol). Always
use <code class="computeroutput"><span class="keyword">operator</span> <span class="identifier">comma</span></code>
for comma operator. Memory member operators must always be explicitly
declared <code class="computeroutput"><span class="keyword">static</span></code>.
</p>
</td></tr><tr><td>
<p>
4
</p>
</td><td>
<p>
Base Classes
</p>
</td><td>
<p>
Use <code class="computeroutput"><span class="identifier">extends</span><span class="special">(</span>
</code><code class="literal"><span class="emphasis"><em>base-classes</em></span></code><code class="computeroutput">
<span class="special">)</span></code> instead of the column
symbol <code class="computeroutput"><span class="special">:</span> </code><code class="literal"><span class="emphasis"><em>base-classes</em></span></code>
to inherit from base classes.
</p>
</td></tr><tr><td>
<p>
5
</p>
</td><td>
<p>
Default Parameters
</p>
</td><td>
<p>
Use <code class="computeroutput"><span class="keyword">default</span> </code><code class="literal"><span class="emphasis"><em>parameter-default</em></span></code>
instead of the assignment symbol <code class="computeroutput"><span class="special">=</span>
</code><code class="literal"><span class="emphasis"><em>parameter-default</em></span></code>
to specify template and function parameter default values.
</p>
</td></tr><tr><td>
<p>
6
</p>
</td><td>
<p>
Member Access Levels
</p>
</td><td>
<p>
Always specify the access level <code class="computeroutput"><span class="keyword">public</span></code>,
<code class="computeroutput"><span class="keyword">protected</span></code>, or <code class="computeroutput"><span class="keyword">private</span></code> (note no trailing comma
<code class="computeroutput"><span class="special">:</span></code>) for every constructor,
destructor, member function, and nested class declaration.
</p>
</td></tr><tr><td>
<p>
7
</p>
</td><td>
<p>
Result and Parameter Types
</p>
</td><td>
<p>
Wrap function result and parameter types within round parenthesis
<code class="computeroutput"><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>type</em></span></code><code class="computeroutput"><span class="special">)</span></code>. The wrapping parenthesis are
allowed but not required for fundamental types containing only
alphanumeric tokens (e.g., both <code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">unsigned</span>
<span class="keyword">int</span><span class="special">)</span></code>
and <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">unsigned</span>
<span class="keyword">int</span></code> are allowed, only <code class="computeroutput"><span class="special">(</span><span class="keyword">int</span><span class="special">&amp;)</span></code> and not <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code> is allowed because of the
non-alphanumeric symbol <code class="computeroutput"><span class="special">&amp;</span></code>,
only <code class="computeroutput"><span class="special">(</span><span class="identifier">mytype</span><span class="special">)</span></code> is allowed because <code class="computeroutput"><span class="identifier">mytype</span></code> is not a fundamental type).
</p>
</td></tr><tr><td>
<p>
8
</p>
</td><td>
<p>
Member Initializers
</p>
</td><td>
<p>
Use <code class="computeroutput"><span class="identifier">initialize</span><span class="special">(</span> </code><code class="literal"><span class="emphasis"><em>member-initializers</em></span></code><code class="computeroutput">
<span class="special">)</span></code> instead of the column
symbol <code class="computeroutput"><span class="special">:</span> </code><code class="literal"><span class="emphasis"><em>member-initializers</em></span></code>
to specify constructor member initializers.
</p>
</td></tr><tr><td>
<p>
9
</p>
</td><td>
<p>
Empty Lists
</p>
</td><td>
<p>
Specify empty lists (parameters, exception specifications, template
specializations, etc) using <code class="computeroutput"><span class="special">(</span>
<span class="keyword">void</span> <span class="special">)</span></code>
instead of <code class="computeroutput"><span class="special">(</span> <span class="special">)</span></code>
or <code class="computeroutput"><span class="special">&lt;</span> <span class="special">&gt;</span></code>.
</p>
</td></tr><tr><td>
<p>
10
</p>
</td><td>
<p>
Commas and Leading Symbols
</p>
</td><td>
<p>
Syntactic elements containing commas and leading non-alphanumeric
symbols must be wrapped within extra round parenthesis <code class="computeroutput"><span class="special">(...)</span></code>. (Note that <code class="computeroutput"><span class="char">'a'</span></code>, <code class="computeroutput"><span class="string">"abc"</span></code>,
<code class="computeroutput"><span class="number">1.23</span></code>, etc are not alphanumeric
so they need to be wrapped as <code class="computeroutput"><span class="special">(</span><span class="char">'a'</span><span class="special">)</span></code>,
<code class="computeroutput"><span class="special">(</span><span class="string">"abc"</span><span class="special">)</span></code>, <code class="computeroutput"><span class="special">(</span><span class="number">1.23</span><span class="special">)</span></code>,
etc when specified as default parameters or similar.)
</p>
</td></tr></tbody></table></div><div class="important" title="Important"><table border="0" summary="Important"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../doc/src/images/important.png"></td><th align="left">Important</th></tr><tr><td align="left" valign="top"><p>
In general, every token which is not a known keyword (<code class="computeroutput"><span class="keyword">int</span></code>
is a known keyword but the function name is not) or that contains a non-alphanumeric
symbol (e.g., <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>)
must be wrapped within round parenthesis <code class="computeroutput"><span class="special">(...)</span></code>
unless it is the very last token of a syntactic element (e.g., the function
parameter name).
</p></td></tr></table></div><p>
Sometimes the C++ syntax allows to equivalently specify elements in different
orders (e.g., <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">volatile</span></code>
and <code class="computeroutput"><span class="keyword">volatile</span> <span class="keyword">const</span></code>
are both allowed for member functions and they have the same meaning). The
syntax of this library requires instead to specify the elements exactly in
the order listed by this grammar (e.g., only <code class="computeroutput"><span class="keyword">const</span>
<span class="keyword">volatile</span></code> is allowed for member functions).
<sup>[<a name="contract__.grammar.differences_with_c___syntax.f0" href="#ftn.contract__.grammar.differences_with_c___syntax.f0" class="footnote">69</a>]</sup>
</p></div><div class="section" title="Macro Interface"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.macro_interface"></a><a class="link" href="#contract__.grammar.macro_interface" title="Macro Interface">Macro Interface</a></h3></div></div></div><p>
This library uses the following macros.
</p><pre class="programlisting"><code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code><span class="special">(</span><a class="link" href="#class_declaration_anchor"><code class="literal"><span class="emphasis"><em>class-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_TPL" title="Macro CONTRACT_CLASS_TPL">CONTRACT_CLASS_TPL</a></code><span class="special">(</span><a class="link" href="#class_declaration_anchor"><code class="literal"><span class="emphasis"><em>class-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code><span class="special">(</span><a class="link" href="#class_invariants_anchor"><code class="literal"><span class="emphasis"><em>class-invariants</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT_TPL" title="Macro CONTRACT_CLASS_INVARIANT_TPL">CONTRACT_CLASS_INVARIANT_TPL</a></code><span class="special">(</span><a class="link" href="#class_invariants_anchor"><code class="literal"><span class="emphasis"><em>class-invariants</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code><span class="special">(</span><a class="link" href="#function_declaration_anchor"><code class="literal"><span class="emphasis"><em>function-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION_TPL" title="Macro CONTRACT_FUNCTION_TPL">CONTRACT_FUNCTION_TPL</a></code><span class="special">(</span><a class="link" href="#function_declaration_anchor"><code class="literal"><span class="emphasis"><em>function-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code><span class="special">(</span><a class="link" href="#function_declaration_anchor"><code class="literal"><span class="emphasis"><em>function-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_TPL" title="Macro CONTRACT_CONSTRUCTOR_TPL">CONTRACT_CONSTRUCTOR_TPL</a></code><span class="special">(</span><a class="link" href="#function_declaration_anchor"><code class="literal"><span class="emphasis"><em>function-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code><span class="special">(</span><a class="link" href="#function_declaration_anchor"><code class="literal"><span class="emphasis"><em>function-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_TPL" title="Macro CONTRACT_DESTRUCTOR_TPL">CONTRACT_DESTRUCTOR_TPL</a></code><span class="special">(</span><a class="link" href="#function_declaration_anchor"><code class="literal"><span class="emphasis"><em>function-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a></code><span class="special">(</span><a class="link" href="#function_name_anchor"><code class="literal"><span class="emphasis"><em>function-name</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code><span class="special">(</span><a class="link" href="#class_type_anchor"><code class="literal"><span class="bold"><strong>class-type</strong></span></code></a><span class="special">,</span> <a class="link" href="#function_name_anchor"><code class="literal"><span class="emphasis"><em>function-name</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_BODY" title="Macro CONTRACT_CONSTRUCTOR_BODY">CONTRACT_CONSTRUCTOR_BODY</a></code><span class="special">(</span><a class="link" href="#class_type_anchor"><code class="literal"><span class="bold"><strong>class-type</strong></span></code></a><span class="special">,</span> <a class="link" href="#class_name_anchor"><code class="literal"><span class="bold"><strong>class-name</strong></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_BODY" title="Macro CONTRACT_DESTRUCTOR_BODY">CONTRACT_DESTRUCTOR_BODY</a></code><span class="special">(</span><a class="link" href="#class_type_anchor"><code class="literal"><span class="bold"><strong>class-type</strong></span></code></a><span class="special">,</span> <span class="special">~</span><a class="link" href="#class_name_anchor"><code class="literal"><span class="bold"><strong>class-name</strong></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT" title="Macro CONTRACT_BLOCK_INVARIANT">CONTRACT_BLOCK_INVARIANT</a></code><span class="special">(</span><a class="link" href="#assertions_anchor"><code class="literal"><span class="emphasis"><em>assertions</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT_TPL" title="Macro CONTRACT_BLOCK_INVARIANT_TPL">CONTRACT_BLOCK_INVARIANT_TPL</a></code><span class="special">(</span><a class="link" href="#assertions_anchor"><code class="literal"><span class="emphasis"><em>assertions</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_LOOP" title="Macro CONTRACT_LOOP">CONTRACT_LOOP</a></code><span class="special">(</span><a class="link" href="#loop_declaration_anchor"><code class="literal"><span class="bold"><strong>loop-declaration</strong></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT" title="Macro CONTRACT_LOOP_VARIANT">CONTRACT_LOOP_VARIANT</a></code><span class="special">(</span><a class="link" href="#loop_variant_anchor"><code class="literal"><span class="emphasis"><em>loop-variant</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT_TPL" title="Macro CONTRACT_LOOP_VARIANT_TPL">CONTRACT_LOOP_VARIANT_TPL</a></code><span class="special">(</span><a class="link" href="#loop_variant_anchor"><code class="literal"><span class="emphasis"><em>loop-variant</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_ARG" title="Macro CONTRACT_CONSTRUCTOR_ARG">CONTRACT_CONSTRUCTOR_ARG</a></code><span class="special">(</span><a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_TYPEOF" title="Macro CONTRACT_PARAMETER_TYPEOF">CONTRACT_PARAMETER_TYPEOF</a></code><span class="special">(</span><a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code><span class="special">(</span><a class="link" href="#named_parameter_declaration_anchor"><code class="literal"><span class="emphasis"><em>named-parameter-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_TEMPLATE_PARAMETER" title="Macro CONTRACT_TEMPLATE_PARAMETER">CONTRACT_TEMPLATE_PARAMETER</a></code><span class="special">(</span><a class="link" href="#named_parameter_declaration_anchor"><code class="literal"><span class="emphasis"><em>named-parameter-declaration</em></span></code></a><span class="special">)</span>
<code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_BODY" title="Macro CONTRACT_PARAMETER_BODY">CONTRACT_PARAMETER_BODY</a></code><span class="special">(</span><a class="link" href="#function_name_anchor"><code class="literal"><span class="emphasis"><em>function-name</em></span></code></a><span class="special">)</span>
</pre><p>
The macros with the trailing <code class="computeroutput"><span class="identifier">_TPL</span></code>
must be used when the enclosing scope is type-dependent (e.g., within templates).
</p></div><div class="section" title="Lexical Conventions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.lexical_conventions"></a><a class="link" href="#contract__.grammar.lexical_conventions" title="Lexical Conventions">Lexical Conventions</a></h3></div></div></div><p>
The following conventions are used to express this grammar.
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
Lexical Expression
</p>
</th><th>
<p>
Meaning
</p>
</th></tr></thead><tbody><tr><td>
<p>
<code class="literal"><span class="emphasis"><em>[</em></span>tokens<span class="emphasis"><em>]</em></span></code>
</p>
</td><td>
<p>
Either <code class="computeroutput"><span class="identifier">tokens</span></code> or
nothing (optional tokens).
</p>
</td></tr><tr><td>
<p>
<code class="literal"><span class="emphasis"><em>{</em></span>expression<span class="emphasis"><em>}</em></span></code>
</p>
</td><td>
<p>
The result of the enclosed expression <code class="computeroutput"><span class="identifier">expression</span></code>
(evaluation order).
</p>
</td></tr><tr><td>
<p>
<code class="literal">tokens1 <span class="emphasis"><em>|</em></span> tokens2</code>
</p>
</td><td>
<p>
Either <code class="computeroutput"><span class="identifier">tokens1</span></code>
or <code class="computeroutput"><span class="identifier">tokens2</span></code> (<span class="quote">&#8220;<span class="quote">or</span>&#8221;</span>
operation).
</p>
</td></tr><tr><td>
<p>
<code class="literal">tokens<span class="emphasis"><em>*</em></span></code>
</p>
</td><td>
<p>
<code class="computeroutput"><span class="identifier">tokens</span></code> repeated
zero or more times (repetition starting from zero).
</p>
</td></tr><tr><td>
<p>
<code class="literal">tokens<span class="emphasis"><em>+</em></span></code>
</p>
</td><td>
<p>
<code class="computeroutput"><span class="identifier">tokens</span></code> repeated
one or more times (repetition starting from one).
</p>
</td></tr><tr><td>
<p>
<code class="literal">token, ...</code>
</p>
</td><td>
<p>
A comma separated list of tokens that could also have one single
element (i.e., <code class="computeroutput"><span class="identifier">token</span></code>
or <code class="computeroutput"><span class="identifier">token1</span><span class="special">,</span>
<span class="identifier">token2</span></code> or <code class="computeroutput"><span class="identifier">token1</span><span class="special">,</span>
<span class="identifier">token2</span><span class="special">,</span>
<span class="identifier">token3</span></code>). See the <a class="link" href="#contract__.no_variadic_macros" title="No Variadic Macros">No Variadic Macros</a>
section for compilers that do not support variadic macros.
</p>
</td></tr><tr><td>
<p>
<code class="literal"><span class="bold"><strong>tokens</strong></span></code>
</p>
</td><td>
<p>
Terminal symbols (in bold font).
</p>
</td></tr><tr><td>
<p>
<code class="literal"><span class="emphasis"><em>tokens</em></span></code>
</p>
</td><td>
<p>
Non-terminal symbols (in italic font).
</p>
</td></tr></tbody></table></div></div><div class="section" title="Class Declarations"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.class_declarations"></a><a class="link" href="#contract__.grammar.class_declarations" title="Class Declarations">Class Declarations</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#class_declaration_anchor"><code class="literal"><span class="emphasis"><em>class-declaration</em></span></code></a>: <a name="class_declaration_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="emphasis"><em>[</em></span><span class="keyword">export</span><span class="emphasis"><em>]</em></span> <span class="keyword">template</span><span class="special">(</span> <a class="link" href="#template_parameters_anchor"><code class="literal"><span class="emphasis"><em>template-parameters</em></span></code></a> <span class="special">)</span> <span class="emphasis"><em>[</em></span><span class="identifier">requires</span><span class="special">(</span> <a class="link" href="#concepts_anchor"><code class="literal"><span class="emphasis"><em>concepts</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="keyword">friend</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>{</em></span><span class="keyword">class</span> <span class="emphasis"><em>|</em></span> <span class="keyword">struct</span><span class="emphasis"><em>}</em></span> <span class="special">(</span><a class="link" href="#class_name_anchor"><code class="literal"><span class="bold"><strong>class-name</strong></span></code></a><span class="special">)</span><span class="emphasis"><em>[</em></span><span class="special">(</span> <a class="link" href="#template_specializations_anchor"><code class="literal"><span class="emphasis"><em>template-specializations</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="identifier">final</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="identifier">extends</span><span class="special">(</span> <a class="link" href="#base_classes_anchor"><code class="literal"><span class="emphasis"><em>base-classes</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span>
</pre></div><div class="section" title="Base Classes"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.base_classes"></a><a class="link" href="#contract__.grammar.base_classes" title="Base Classes">Base Classes</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#base_classes_anchor"><code class="literal"><span class="emphasis"><em>base-classes</em></span></code></a>: <a name="base_classes_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">public</span> <span class="emphasis"><em>|</em></span> <span class="keyword">protected</span> <span class="emphasis"><em>|</em></span> <span class="keyword">private</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">virtual</span><span class="emphasis"><em>]</em></span> <a class="link" href="#class_type_anchor"><code class="literal"><span class="bold"><strong>class-type</strong></span></code></a><span class="special">,</span> <span class="special">...</span>
</pre><p>
Note that when specified, <code class="computeroutput"><span class="keyword">virtual</span></code>
must appear after the inheritance access level for a base class.
</p></div><div class="section" title="Template Specializations"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.template_specializations"></a><a class="link" href="#contract__.grammar.template_specializations" title="Template Specializations">Template
Specializations</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#template_specializations_anchor"><code class="literal"><span class="emphasis"><em>template-specializations</em></span></code></a>: <a name="template_specializations_anchor"></a>
<a class="link" href="#template_specialization_anchor"><code class="literal"><span class="bold"><strong>template-specialization</strong></span></code></a><span class="special">,</span> <span class="special">...</span>
</pre></div><div class="section" title="Template Parameters"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.template_parameters"></a><a class="link" href="#contract__.grammar.template_parameters" title="Template Parameters">Template Parameters</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#template_parameters_anchor"><code class="literal"><span class="emphasis"><em>template-parameters</em></span></code></a>: <a name="template_parameters_anchor"></a>
<span class="keyword">void</span> <span class="emphasis"><em>|</em></span>
<a class="link" href="#positional_template_parameters_anchor"><code class="literal"><span class="emphasis"><em>positional-template-parameters</em></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#named_template_parameters_anchor"><code class="literal"><span class="emphasis"><em>named-template-parameters</em></span></code></a>
<a class="link" href="#positional_template_parameters_anchor"><code class="literal"><span class="emphasis"><em>positional-template-parameters</em></span></code></a>: <a name="positional_template_parameters_anchor"></a>
<a class="link" href="#positional_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-template-parameter</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#positional_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-template-parameter</em></span></code></a>: <a name="positional_template_parameter_anchor"></a>
<a class="link" href="#positional_type_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-type-template-parameter</em></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#positional_value_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-value-template-parameter</em></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#positional_template_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-template-template-parameter</em></span></code></a>
<a class="link" href="#positional_type_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-type-template-parameter</em></span></code></a>: <a name="positional_type_template_parameter_anchor"></a>
<span class="emphasis"><em>{</em></span><span class="keyword">class</span> <span class="emphasis"><em>|</em></span> <span class="keyword">typename</span><span class="emphasis"><em>}</em></span> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
<a class="link" href="#positional_value_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-value-template-parameter</em></span></code></a>: <a name="positional_value_template_parameter_anchor"></a>
<a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
<a class="link" href="#positional_template_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-template-template-parameter</em></span></code></a>: <a name="positional_template_template_parameter_anchor"></a>
<span class="keyword">template</span><span class="special">(</span> <a class="link" href="#template_parameter_anchor"><code class="literal"><span class="bold"><strong>template-parameter</strong></span></code></a><span class="special">,</span> <span class="special">...</span> <span class="special">)</span> <span class="keyword">class</span> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
<a class="link" href="#named_template_parameters_anchor"><code class="literal"><span class="emphasis"><em>named-template-parameters</em></span></code></a>: <a name="named_template_parameters_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">using</span> <span class="keyword">namespace</span> <a class="link" href="#named_parameter_identifier_namespace_anchor"><code class="literal"><span class="bold"><strong>named-parameter-identifier-namespace</strong></span></code></a><span class="special">,</span><span class="emphasis"><em>]</em></span>
<a class="link" href="#named_type_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-type-template-parameter</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#named_type_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-type-template-parameter</em></span></code></a>: <a name="named_type_template_parameter_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="identifier">deduce</span><span class="emphasis"><em>]</em></span> <span class="identifier">in</span> <span class="emphasis"><em>{</em></span><span class="keyword">class</span> <span class="emphasis"><em>|</em></span> <span class="keyword">typename</span><span class="emphasis"><em>}</em></span>
<span class="emphasis"><em>[</em></span><span class="identifier">requires</span><span class="special">(</span><a class="link" href="#unary_boolean_metafunction_anchor"><code class="literal"><span class="bold"><strong>unary-boolean-metafunction</strong></span></code></a><span class="special">)</span><span class="emphasis"><em>]</em></span> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
</pre><p>
Note that if <code class="computeroutput"><span class="keyword">typename</span></code> appears
within <a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a>
for a value template parameter then it will be wrapped within parenthesis
<code class="computeroutput"><span class="special">(</span><span class="keyword">typename</span>
<span class="special">...)</span></code> so it is syntactically distinguishable
from the <code class="computeroutput"><span class="keyword">typename</span></code> leading a
type template parameter.
</p><p>
Unfortunately, named template parameters only support type template parameters.
Named value template parameters and named template template parameters are
not supported because they are not supported by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
but if they were ever supported, they could follow this syntax:
</p><pre class="programlisting"><a class="link" href="#named_template_parameters_anchor"><code class="literal"><span class="emphasis"><em>named-template-parameters</em></span></code></a>:
<a class="link" href="#named_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-template-parameter</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#named_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-template-parameter</em></span></code></a>: <a name="named_template_parameter_anchor"></a>
<a class="link" href="#named_type_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-type-template-parameter</em></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#named_value_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-value-template-parameter</em></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#named_template_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-template-template-parameter</em></span></code></a>
<a class="link" href="#named_value_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-value-template-parameter</em></span></code></a>: <a name="named_value_template_parameter_anchor"></a><span class="comment">// Not supported.</span>
<span class="emphasis"><em>[</em></span><span class="identifier">deduce</span><span class="emphasis"><em>]</em></span> <span class="identifier">in</span>
<span class="emphasis"><em>{</em></span><a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a> <span class="emphasis"><em>|</em></span> <span class="keyword">auto</span> <span class="emphasis"><em>|</em></span> <span class="identifier">requires</span><span class="special">(</span><a class="link" href="#unary_boolean_metafunction_anchor"><code class="literal"><span class="bold"><strong>unary-boolean-metafunction</strong></span></code></a><span class="special">)</span><span class="emphasis"><em>}</em></span> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
<a class="link" href="#named_template_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-template-template-parameter</em></span></code></a>: <a name="named_template_template_parameter_anchor"></a><span class="comment">// Not supported.</span>
<span class="emphasis"><em>[</em></span><span class="identifier">deduce</span><span class="emphasis"><em>]</em></span> <span class="identifier">in</span> <span class="keyword">template</span><span class="special">(</span> <a class="link" href="#positional_template_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-template-parameter</em></span></code></a><span class="special">,</span> <span class="special">...</span> <span class="special">)</span> <span class="keyword">class</span>
<span class="emphasis"><em>[</em></span><span class="identifier">requires</span><span class="special">(</span><a class="link" href="#unary_boolean_metafunction_anchor"><code class="literal"><span class="bold"><strong>unary-boolean-metafunction</strong></span></code></a><span class="special">)</span><span class="emphasis"><em>]</em></span> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
<span class="keyword">template</span><span class="special">(</span> <span class="comment">// For example...</span>
<span class="comment">// Named type template parameter (supported).</span>
<span class="identifier">in</span> <span class="keyword">typename</span> <span class="identifier">requires</span><span class="special">(</span><span class="identifier">is_const</span><span class="special">&lt;</span><span class="identifier">_</span><span class="special">&gt;)</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">default</span> <span class="keyword">int</span>
<span class="comment">// Named value template parameter (not supported).</span>
<span class="special">,</span> <span class="identifier">in</span> <span class="identifier">requires</span><span class="special">(</span><span class="identifier">is_converible</span><span class="special">&lt;</span><span class="identifier">_</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">default</span> <span class="number">0</span>
<span class="comment">// Named template template parameter (not supported).</span>
<span class="special">,</span> <span class="identifier">in</span> <span class="keyword">template</span><span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">A</span>
<span class="special">,</span> <span class="keyword">template</span><span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">X</span>
<span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Y</span><span class="special">,</span> <span class="keyword">default</span> <span class="keyword">int</span>
<span class="special">)</span> <span class="keyword">class</span> <span class="identifier">B</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">b</span>
<span class="special">)</span> <span class="keyword">class</span> <span class="identifier">requires</span><span class="special">(</span><span class="identifier">pred1</span><span class="special">&lt;</span> <span class="identifier">_</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;)</span> <span class="identifier">Tpl</span><span class="special">,</span> <span class="keyword">default</span> <span class="identifier">tpl</span>
<span class="special">)</span>
</pre></div><div class="section" title="Concepts"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.concepts"></a><a class="link" href="#contract__.grammar.concepts" title="Concepts">Concepts</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#concepts_anchor"><code class="literal"><span class="emphasis"><em>concepts</em></span></code></a>: <a name="concepts_anchor"></a>
<a class="link" href="#boost_concept_anchor"><code class="literal"><span class="bold"><strong>boost-concept</strong></span></code></a><span class="special">,</span> <span class="special">...</span>
</pre></div><div class="section" title="Types"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.types"></a><a class="link" href="#contract__.grammar.types" title="Types">Types</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a>: <a name="wrapped_type_anchor"></a>
<a class="link" href="#fundamental_type_anchor"><code class="literal"><span class="emphasis"><em>fundamental-type</em></span></code></a> <span class="emphasis"><em>|</em></span> <span class="special">(</span><a class="link" href="#fundamental_type_anchor"><code class="literal"><span class="emphasis"><em>fundamental-type</em></span></code></a><span class="special">)</span> <span class="emphasis"><em>|</em></span> <span class="special">(</span><a class="link" href="#type_anchor"><code class="literal"><span class="bold"><strong>type</strong></span></code></a><span class="special">)</span>
<a class="link" href="#fundamental_type_anchor"><code class="literal"><span class="emphasis"><em>fundamental-type</em></span></code></a>: <a name="fundamental_type_anchor"></a>
<a class="link" href="#type_qualifier_anchor"><code class="literal"><span class="emphasis"><em>type-qualifier</em></span></code></a><span class="emphasis"><em>*</em></span> <a class="link" href="#type_keyword_anchor"><code class="literal"><span class="emphasis"><em>type-keyword</em></span></code></a> <a class="link" href="#type_qualifier_anchor"><code class="literal"><span class="emphasis"><em>type-qualifier</em></span></code></a><span class="emphasis"><em>*</em></span>
<a class="link" href="#type_qualifier_anchor"><code class="literal"><span class="emphasis"><em>type-qualifier</em></span></code></a>: <a name="type_qualifier_anchor"></a>
<span class="keyword">const</span> <span class="emphasis"><em>|</em></span> <span class="keyword">volatile</span> <span class="emphasis"><em>|</em></span> <span class="keyword">long</span> <span class="emphasis"><em>|</em></span> <span class="keyword">short</span> <span class="emphasis"><em>|</em></span> <span class="keyword">signed</span> <span class="emphasis"><em>|</em></span> <span class="keyword">unsigned</span>
<a class="link" href="#type_keyword_anchor"><code class="literal"><span class="emphasis"><em>type-keyword</em></span></code></a>: <a name="type_keyword_anchor"></a>
<span class="keyword">void</span> <span class="emphasis"><em>|</em></span> <span class="keyword">bool</span> <span class="emphasis"><em>|</em></span> <span class="keyword">char</span> <span class="emphasis"><em>|</em></span> <span class="keyword">double</span> <span class="emphasis"><em>|</em></span> <span class="keyword">float</span> <span class="emphasis"><em>|</em></span> <span class="keyword">int</span> <span class="emphasis"><em>|</em></span> <span class="keyword">wchar_t</span> <span class="emphasis"><em>|</em></span> <span class="identifier">size_t</span> <span class="emphasis"><em>|</em></span> <span class="identifier">ptrdiff_t</span>
</pre><p>
This is the syntax used to specify the function result type, the function
parameter types, the types of value template parameters, etc. As indicated
by the syntax, extra parenthesis around the specified type are always allowed
but they are required only for user-defined types <code class="computeroutput"><span class="special">(</span><span class="identifier">mytype</span><span class="special">)</span></code>
and types containing non-alphanumeric symbols <code class="computeroutput"><span class="special">(</span><span class="keyword">int</span><span class="special">&amp;)</span></code>
while the parenthesis are optional for fundamental types containing no symbol
<code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">long</span>
<span class="keyword">int</span> <span class="keyword">const</span></code>
(or equivalently <code class="computeroutput"><span class="special">(</span><span class="keyword">unsigned</span>
<span class="keyword">long</span> <span class="keyword">int</span>
<span class="keyword">const</span><span class="special">)</span></code>).
</p></div><div class="section" title="Function Declarations"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.function_declarations"></a><a class="link" href="#contract__.grammar.function_declarations" title="Function Declarations">Function Declarations</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#function_declaration_anchor"><code class="literal"><span class="emphasis"><em>function-declaration</em></span></code></a>: <a name="function_declaration_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">public</span> <span class="emphasis"><em>|</em></span> <span class="keyword">protected</span> <span class="emphasis"><em>|</em></span> <span class="keyword">private</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="emphasis"><em>[</em></span><span class="keyword">export</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">template</span><span class="special">(</span> <a class="link" href="#template_parameters_anchor"><code class="literal"><span class="emphasis"><em>template-parameters</em></span></code></a> <span class="special">)</span> <span class="emphasis"><em>[</em></span><span class="identifier">requires</span><span class="special">(</span> <a class="link" href="#concepts_anchor"><code class="literal"><span class="emphasis"><em>concepts</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="keyword">explicit</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">inline</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">extern</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">static</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">virtual</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">friend</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><a class="link" href="#result_type_anchor"><code class="literal"><span class="emphasis"><em>result-type</em></span></code></a><span class="emphasis"><em>]</em></span> <a class="link" href="#function_name_anchor"><code class="literal"><span class="emphasis"><em>function-name</em></span></code></a> <span class="special">(</span> <a class="link" href="#function_parameters_anchor"><code class="literal"><span class="emphasis"><em>function-parameters</em></span></code></a> <span class="special">)</span>
<span class="emphasis"><em>[</em></span><span class="identifier">requires</span><span class="special">(</span> <a class="link" href="#concepts_anchor"><code class="literal"><span class="emphasis"><em>concepts</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="keyword">const</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="keyword">volatile</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="identifier">override</span> <span class="emphasis"><em>|</em></span> <span class="keyword">new</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>[</em></span><span class="identifier">final</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="keyword">throw</span><span class="special">(</span> <a class="link" href="#exception_specifications_anchor"><code class="literal"><span class="emphasis"><em>exception-specifications</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="identifier">precondition</span><span class="special">(</span> <a class="link" href="#assertions_anchor"><code class="literal"><span class="emphasis"><em>assertions</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="identifier">postcondition</span><span class="special">(</span> <a class="link" href="#result_oldof_assertions_anchor"><code class="literal"><span class="emphasis"><em>result-oldof-assertions</em></span></code></a> <span class="special">)</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><a class="link" href="#member_initializers_anchor"><code class="literal"><span class="emphasis"><em>member-initializers</em></span></code></a><span class="emphasis"><em>]</em></span>
</pre><p>
This is the syntax used to declare all functions: Free functions, member
functions, constructors, destructors, and operators. The usual constraints
of C++ function declarations apply: It is not possible to declare a static
virtual member function, only constructors can use the class name as the
function name, constructors and destructors have no result type, etc. The
<code class="computeroutput"><span class="keyword">static</span></code> specifier can only be
used for member functions (because it was deprecated for free functions from
C to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>). The
<code class="computeroutput"><span class="keyword">volatile</span></code> specifier must always
appear after <code class="computeroutput"><span class="keyword">const</span></code> when they
are both specified.
</p></div><div class="section" title="Result Type"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.result_type"></a><a class="link" href="#contract__.grammar.result_type" title="Result Type">Result Type</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#result_type_anchor"><code class="literal"><span class="emphasis"><em>result-type</em></span></code></a>: <a name="result_type_anchor"></a>
<a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a>
</pre><p>
Note that fundamental types containing no symbol can be specified without
extra parenthesis: <code class="computeroutput"><span class="keyword">void</span></code>, <code class="computeroutput"><span class="keyword">bool</span></code>, <code class="computeroutput"><span class="keyword">int</span></code>,
<code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">long</span>
<span class="keyword">const</span></code>, etc.
</p></div><div class="section" title="Function and Operator Names"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.function_and_operator_names"></a><a class="link" href="#contract__.grammar.function_and_operator_names" title="Function and Operator Names">Function
and Operator Names</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#function_name_anchor"><code class="literal"><span class="emphasis"><em>function-name</em></span></code></a>: <a name="function_name_anchor"></a>
<span class="special">(</span><a class="link" href="#function_identifier_anchor"><code class="literal"><span class="bold"><strong>function-identifier</strong></span></code></a><span class="special">)</span> <span class="emphasis"><em>|</em></span> <span class="special">(</span><a class="link" href="#class_name_anchor"><code class="literal"><span class="bold"><strong>class-name</strong></span></code></a><span class="special">)</span> <span class="emphasis"><em>|</em></span> <span class="special">(~</span><a class="link" href="#class_name_anchor"><code class="literal"><span class="bold"><strong>class-name</strong></span></code></a><span class="special">)</span> <span class="emphasis"><em>|</em></span> <a class="link" href="#operator_name_anchor"><code class="literal"><span class="emphasis"><em>operator-name</em></span></code></a>
<a class="link" href="#operator_name_anchor"><code class="literal"><span class="emphasis"><em>operator-name</em></span></code></a>: <a name="operator_name_anchor"></a>
<span class="keyword">operator</span><span class="special">(</span><a class="link" href="#operator_symbol_anchor"><code class="literal"><span class="bold"><strong>operator-symbol</strong></span></code></a><span class="special">)(</span><a class="link" href="#operator_identifier_anchor"><code class="literal"><span class="bold"><strong>operator-identifier</strong></span></code></a><span class="special">)</span> <span class="emphasis"><em>|</em></span> <span class="keyword">operator</span> <a class="link" href="#fundamental_type_anchor"><code class="literal"><span class="emphasis"><em>fundamental-type</em></span></code></a> <span class="emphasis"><em>|</em></span>
<span class="keyword">operator</span> <span class="keyword">new</span> <span class="emphasis"><em>|</em></span> <span class="keyword">operator</span> <span class="keyword">delete</span> <span class="emphasis"><em>|</em></span> <span class="keyword">operator</span> <span class="identifier">comma</span>
</pre><p>
Names for free functions, member functions, constructors, and destructors
are specified as usual but wrapped within parenthesis.
</p><p>
Operator names are specified wrapping within parenthesis the usual operator
symbol followed by an arbitrary but alphanumeric identifier:
</p><pre class="programlisting"><span class="keyword">operator</span><span class="special">([])(</span><span class="identifier">at</span><span class="special">)</span>
<span class="keyword">operator</span><span class="special">(+)(</span><span class="identifier">plus</span><span class="special">)</span>
<span class="keyword">operator</span><span class="special">(())(</span><span class="identifier">call</span><span class="special">)</span>
<span class="keyword">operator</span><span class="special">(</span><span class="keyword">new</span><span class="special">[])(</span><span class="identifier">new_array</span><span class="special">)</span>
<span class="keyword">operator</span><span class="special">(</span><span class="keyword">delete</span><span class="special">[])(</span><span class="identifier">delete_array</span><span class="special">)</span>
</pre><p>
Implicit type conversion operators use the same syntax:
</p><pre class="programlisting"><span class="keyword">operator</span><span class="special">(</span><span class="keyword">int</span><span class="special">*)(</span><span class="identifier">int_ptr</span><span class="special">)</span>
<span class="keyword">operator</span><span class="special">(</span><span class="identifier">mytype</span> <span class="keyword">const</span><span class="special">&amp;)(</span><span class="identifier">mytype_const_ref</span><span class="special">)</span>
<span class="keyword">operator</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;)(</span><span class="identifier">std_map</span><span class="special">)</span>
</pre><p>
However, if the type is a fundamental type containing no symbol, the identifier
is optional:
</p><pre class="programlisting"><span class="keyword">operator</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">int</span><span class="special">)(</span><span class="identifier">const_int</span><span class="special">)</span> <span class="comment">// Allowed but...</span>
<span class="keyword">operator</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="comment">// ... more readable.</span>
</pre><p>
Similarly, the parenthesis and identifier are optional for the <code class="computeroutput"><span class="keyword">new</span></code> and <code class="computeroutput"><span class="keyword">delete</span></code>
operators:
</p><pre class="programlisting"><span class="keyword">operator</span><span class="special">(</span><span class="keyword">new</span><span class="special">)(</span><span class="identifier">new_ptr</span><span class="special">)</span> <span class="comment">// Allowed but...</span>
<span class="keyword">operator</span> <span class="keyword">new</span> <span class="comment">// ... more readable.</span>
<span class="keyword">operator</span><span class="special">(</span><span class="keyword">delete</span><span class="special">)(</span><span class="identifier">delete_ptr</span><span class="special">)</span> <span class="comment">// Allowed but...</span>
<span class="keyword">operator</span> <span class="keyword">delete</span> <span class="comment">// ... more readable.</span>
</pre><p>
Finally, the comma symbol <code class="computeroutput"><span class="special">,</span></code>
cannot be used to specify the comma operator <sup>[<a name="contract__.grammar.function_and_operator_names.f0" href="#ftn.contract__.grammar.function_and_operator_names.f0" class="footnote">70</a>]</sup> so the specifier <code class="computeroutput"><span class="identifier">comma</span></code>
must always be used to name the comma operator:
</p><pre class="programlisting"><span class="keyword">operator</span> <span class="identifier">comma</span> <span class="comment">// OK.</span>
<span class="keyword">operator</span><span class="special">(,)(</span><span class="identifier">comma</span><span class="special">)</span> <span class="comment">// Error.</span>
</pre><p>
C++ automatically promotes the memory member operators <code class="computeroutput"><span class="keyword">operator</span>
<span class="keyword">new</span></code>, <code class="computeroutput"><span class="keyword">operator</span>
<span class="keyword">delete</span></code>, <code class="computeroutput"><span class="keyword">operator</span>
<span class="keyword">new</span><span class="special">[]</span></code>,
and <code class="computeroutput"><span class="keyword">operator</span> <span class="keyword">delete</span><span class="special">[]</span></code> to be static members so the <code class="computeroutput"><span class="keyword">static</span></code> specifier is allowed but optional for
these member operators. This library cannot automatically perform such a
promotion so the <code class="computeroutput"><span class="keyword">static</span></code> specifier
is always required by this library for the memory member operators.
</p></div><div class="section" title="Exception Specifications"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.exception_specifications"></a><a class="link" href="#contract__.grammar.exception_specifications" title="Exception Specifications">Exception
Specifications</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#exception_specifications_anchor"><code class="literal"><span class="emphasis"><em>exception-specifications</em></span></code></a>: <a name="exception_specifications_anchor"></a>
<span class="keyword">void</span> <span class="special">|</span> <a class="link" href="#exception_type_anchor"><code class="literal"><span class="bold"><strong>exception-type</strong></span></code></a><span class="special">,</span> <span class="special">...</span>
</pre><p>
Note that the syntax <code class="computeroutput"><span class="keyword">throw</span><span class="special">(</span>
<span class="keyword">void</span> <span class="special">)</span></code>
is used instead of <code class="computeroutput"><span class="keyword">throw</span><span class="special">(</span>
<span class="special">)</span></code> for no-throw specifications.
</p><p>
Exception specifications apply only to exceptions thrown by the function
body and not to exceptions thrown by the contracts themselves (if any) and
by the contract checking code generated by this library macros.
</p></div><div class="section" title="Member Initializers"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.member_initializers"></a><a class="link" href="#contract__.grammar.member_initializers" title="Member Initializers">Member Initializers</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#member_initializers_anchor"><code class="literal"><span class="emphasis"><em>member-initializers</em></span></code></a>: <a name="member_initializers_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">try</span><span class="emphasis"><em>]</em></span> <span class="identifier">initialize</span><span class="special">(</span> <a class="link" href="#member_initializer_anchor"><code class="literal"><span class="bold"><strong>member-initializer</strong></span></code></a><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
<span class="emphasis"><em>{</em></span><span class="keyword">catch</span><span class="special">(</span><a class="link" href="#catch_declaration_anchor"><code class="literal"><span class="bold"><strong>catch-declaration</strong></span></code></a><span class="special">)</span> <span class="special">(</span> <a class="link" href="#catch_instructions_anchor"><code class="literal"><span class="bold"><strong>catch-instructions</strong></span></code></a> <span class="special">)</span><span class="emphasis"><em>}*</em></span>
</pre><p>
As indicated by this syntax, it is possible to specify function-try blocks
for constructor member initializers:
</p><pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">vector_error</span> <span class="special">{</span> <span class="special">...</span> <span class="special">};</span>
<span class="identifier">CONTRACT_CONSTRUCTOR</span><span class="special">(</span> <span class="comment">// Constructor with member initializers.</span>
<span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">int</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="keyword">try</span> <span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">ptr_</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">T</span><span class="special">[</span><span class="identifier">count</span><span class="special">])</span> <span class="special">)</span>
<span class="keyword">catch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"not enough memory for "</span> <span class="special">&lt;&lt;</span> <span class="identifier">count</span> <span class="special">&lt;&lt;</span> <span class="string">" elements vector: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ex</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span> <span class="identifier">vector_error</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
<span class="special">)</span> <span class="keyword">catch</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span><span class="special">&amp;</span> <span class="identifier">ex</span><span class="special">)</span> <span class="special">(</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"error for "</span> <span class="special">&lt;&lt;</span> <span class="identifier">count</span> <span class="special">&lt;&lt;</span> <span class="string">" elements vector: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ex</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span> <span class="identifier">vector_error</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
<span class="special">)</span> <span class="keyword">catch</span><span class="special">(...)</span> <span class="special">(</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cerr</span> <span class="special">&lt;&lt;</span> <span class="string">"unknown error for "</span> <span class="special">&lt;&lt;</span> <span class="identifier">count</span> <span class="special">&lt;&lt;</span> <span class="string">" elements vector"</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="keyword">throw</span> <span class="identifier">vector_error</span><span class="special">(</span><span class="number">3</span><span class="special">);</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span> <span class="comment">// Above function-try block only applies to exceptions thrown by the body (and not by the contracts).</span>
<span class="special">...</span>
<span class="special">}</span>
</pre><p>
For functions other than constructors and for constructors without member
initializers, function-try blocks are programmed outside the macros and around
the body definition as usual. As specified by <a class="link" href="#N1962_anchor">[N1962]</a>,
function-try blocks apply only to exceptions thrown by the function body
and not to exceptions thrown by the contracts themselves (if any) and by
the contract checking code generated by the library macros.
</p><p>
Member initializers (and their function-try blocks) are part of the constructor
definition and not of the constructor declaration. However, <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
lack of delegating constructors requires member initializers (and their function-try
blocks) to be specified within this library macros and constructors must
be defined together with their declarations when they use member initializers.
</p></div><div class="section" title="Function Parameters"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.function_parameters"></a><a class="link" href="#contract__.grammar.function_parameters" title="Function Parameters">Function Parameters</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#function_parameters_anchor"><code class="literal"><span class="emphasis"><em>function-parameters</em></span></code></a>: <a name="function_parameters_anchor"></a>
<span class="keyword">void</span> <span class="emphasis"><em>|</em></span>
<a class="link" href="#positional_function_parameters_anchor"><code class="literal"><span class="emphasis"><em>positional-function-parameters</em></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#named_function_parameters_anchor"><code class="literal"><span class="emphasis"><em>named-function-parameters</em></span></code></a>
<a class="link" href="#positional_function_parameters_anchor"><code class="literal"><span class="emphasis"><em>positional-function-parameters</em></span></code></a>: <a name="positional_function_parameters_anchor"></a>
<a class="link" href="#positional_function_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-function-parameter</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#positional_function_parameter_anchor"><code class="literal"><span class="emphasis"><em>positional-function-parameter</em></span></code></a>: <a name="positional_function_parameter_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">auto</span> <span class="emphasis"><em>|</em></span> <span class="keyword">register</span><span class="emphasis"><em>]</em></span> <a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
<a class="link" href="#named_function_parameters_anchor"><code class="literal"><span class="emphasis"><em>named-function-parameters</em></span></code></a>: <a name="named_function_parameters_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">using</span> <span class="keyword">namespace</span> <a class="link" href="#named_parameter_identifier_namespace_anchor"><code class="literal"><span class="bold"><strong>named-parameter-identifier-namespace</strong></span></code></a><span class="special">,</span><span class="emphasis"><em>]</em></span>
<a class="link" href="#named_function_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-function-parameter</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#named_function_parameter_anchor"><code class="literal"><span class="emphasis"><em>named-function-parameter</em></span></code></a>: <a name="named_function_parameter_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="identifier">deduce</span><span class="emphasis"><em>]</em></span> <span class="emphasis"><em>{</em></span><span class="identifier">in</span> <span class="emphasis"><em>|</em></span> <span class="identifier">out</span> <span class="emphasis"><em>|</em></span> <span class="identifier">in</span> <span class="identifier">out</span><span class="emphasis"><em>}</em></span>
<span class="emphasis"><em>{</em></span><a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a> <span class="emphasis"><em>|</em></span> <span class="keyword">auto</span> <span class="emphasis"><em>|</em></span> <span class="identifier">requires</span><span class="special">(</span><a class="link" href="#unary_boolean_metafunction_anchor"><code class="literal"><span class="bold"><strong>unary-boolean-metafunction</strong></span></code></a><span class="special">)</span><span class="emphasis"><em>}</em></span> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="keyword">default</span> <a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><span class="emphasis"><em>]</em></span>
</pre><p>
Note that the positional parameter storage classifier <code class="computeroutput"><span class="keyword">auto</span></code>
is supported by this library because it is part of <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
(but the <code class="computeroutput"><span class="keyword">auto</span></code> keyword changed
meaning in <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
so use it with the usual care when writing code portable to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>).
</p></div><div class="section" title="Result and Old Values"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.result_and_old_values"></a><a class="link" href="#contract__.grammar.result_and_old_values" title="Result and Old Values">Result and
Old Values</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#result_oldof_assertions_anchor"><code class="literal"><span class="emphasis"><em>result-oldof-assertions</em></span></code></a>: <a name="result_oldof_assertions_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">auto</span> <a class="link" href="#variable_name_anchor"><code class="literal"><span class="bold"><strong>variable-name</strong></span></code></a> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><a class="link" href="#oldof_declaration_anchor"><code class="literal"><span class="emphasis"><em>oldof-declaration</em></span></code></a><span class="special">,</span> <span class="special">...</span><span class="emphasis"><em>]</em></span>
<a class="link" href="#assertion_anchor"><code class="literal"><span class="emphasis"><em>assertion</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#oldof_declaration_anchor"><code class="literal"><span class="emphasis"><em>oldof-declaration</em></span></code></a>: <a name="oldof_declaration_anchor"></a>
<span class="emphasis"><em>{</em></span><span class="keyword">auto</span> <span class="emphasis"><em>|</em></span> <a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a><span class="emphasis"><em>}</em></span> <a class="link" href="#variable_name_anchor"><code class="literal"><span class="bold"><strong>variable-name</strong></span></code></a> <span class="special">=</span> <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code> <a class="link" href="#oldof_expression_anchor"><code class="literal"><span class="bold"><strong>oldof-expression</strong></span></code></a>
</pre><p>
If present, result and old-of declarations should appear at the very beginning
of the postconditions because they will always be visible to all assertions
plus these declarations cannot be nested (within select-assertions, etc).
</p><p>
The result declaration type is always <code class="computeroutput"><span class="keyword">auto</span></code>
because the function result type is know and already specified by the function
declaration (so no result type deduction is ever needed). The old-of declaration
type is automatically deduced (using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>)
when its type is specified <code class="computeroutput"><span class="keyword">auto</span></code>
instead of <a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a>.
The macro <code class="computeroutput"><span class="identifier">CONTRACT_OLDOF</span></code>
does not require but allows parenthesis around the value expression <a class="link" href="#oldof_expression_anchor"><code class="literal"><span class="bold"><strong>oldof-expression</strong></span></code></a>
(this is as specified for the <code class="computeroutput"><span class="identifier">oldof</span></code>
operator in <a class="link" href="#N1962_anchor">[N1962]</a> and similar to the
<code class="computeroutput"><span class="keyword">sizeof</span></code> operator which requires
parenthesis when applied to a type expression <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span></code> but not when applied to a value expression
<code class="computeroutput"><span class="keyword">sizeof</span> <span class="identifier">size</span><span class="special">()</span></code>). For example, all the followings are valid:
</p><pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">()</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span> <span class="comment">// Extra parenthesis around expression (optional).</span>
<span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">()</span> <span class="comment">// Do not use Boost.Typeof.</span>
<span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span> <span class="comment">// No Boost.Typeof and extra parenthesis.</span>
</pre><p>
If an old-of copy is performed on a type that is not <a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies"><code class="literal">ConstantCopyConstructible</code></a>,
the old-of declaration itself will not fail compilation but it will produce
an old variable that will cause a compiler-error as soon as it is used in
an assertion (unless the assertion specifies a requirement using a properly
specialized <code class="computeroutput"><a class="link" href="#contract.has_oldof" title="Struct template has_oldof">contract::has_oldof</a></code>
trait).
</p></div><div class="section" title="Class Invariants"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.class_invariants"></a><a class="link" href="#contract__.grammar.class_invariants" title="Class Invariants">Class Invariants</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#class_invariants_anchor"><code class="literal"><span class="emphasis"><em>class-invariants</em></span></code></a>: <a name="class_invariants_anchor"></a>
<span class="keyword">void</span> <span class="emphasis"><em>|</em></span> <a class="link" href="#class_invariant_anchor"><code class="literal"><span class="emphasis"><em>class-invariant</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#class_invariant_anchor"><code class="literal"><span class="emphasis"><em>class-invariant</em></span></code></a>: <a name="class_invariant_anchor"></a>
<a class="link" href="#assertion_anchor"><code class="literal"><span class="emphasis"><em>assertion</em></span></code></a> <span class="emphasis"><em>|</em></span>
<span class="keyword">static</span> <span class="keyword">class</span><span class="special">(</span> <span class="keyword">void</span> <span class="emphasis"><em>|</em></span> <a class="link" href="#assertion_anchor"><code class="literal"><span class="emphasis"><em>assertion</em></span></code></a><span class="special">,</span> <span class="special">...</span> <span class="special">)</span> <span class="emphasis"><em>|</em></span>
<span class="keyword">volatile</span> <span class="keyword">class</span><span class="special">(</span> <span class="keyword">void</span> <span class="emphasis"><em>|</em></span> <a class="link" href="#assertion_anchor"><code class="literal"><span class="emphasis"><em>assertion</em></span></code></a><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
</pre><p>
Volatile class invariants are assumed to have the same assertions as non-volatile
class invariants unless they are explicitly specified. Static class invariants
are assumed to assert nothing unless they are explicitly specified.
</p></div><div class="section" title="Assertions"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.assertions"></a><a class="link" href="#contract__.grammar.assertions" title="Assertions">Assertions</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#assertions_anchor"><code class="literal"><span class="emphasis"><em>assertions</em></span></code></a>: <a name="assertions_anchor"></a>
<a class="link" href="#assertion_anchor"><code class="literal"><span class="emphasis"><em>assertion</em></span></code></a><span class="special">,</span> <span class="special">...</span>
<a class="link" href="#assertion_anchor"><code class="literal"><span class="emphasis"><em>assertion</em></span></code></a>: <a name="assertion_anchor"></a>
<span class="keyword">using</span> <a class="link" href="#using_directive_anchor"><code class="literal"><span class="bold"><strong>using-directive</strong></span></code></a> <span class="emphasis"><em>|</em></span>
<span class="keyword">namespace</span> <a class="link" href="#namespace_alias_anchor"><code class="literal"><span class="bold"><strong>namespace-alias</strong></span></code></a> <span class="emphasis"><em>|</em></span>
<span class="keyword">typedef</span> <a class="link" href="#typedef_type_anchor"><code class="literal"><span class="bold"><strong>typedef-type</strong></span></code></a> <a class="link" href="#new_type_name_anchor"><code class="literal"><span class="bold"><strong>new-type-name</strong></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#assertion_condition_anchor"><code class="literal"><span class="emphasis"><em>assertion-condition</em></span></code></a>
<a class="link" href="#assertion_condition_anchor"><code class="literal"><span class="emphasis"><em>assertion-condition</em></span></code></a>: <a name="assertion_condition_anchor"></a>
<a class="link" href="#assertion_expression_anchor"><code class="literal"><span class="emphasis"><em>assertion-expression</em></span></code></a> <span class="emphasis"><em>|</em></span>
<a class="link" href="#select_assertion_anchor"><code class="literal"><span class="emphasis"><em>select-assertion</em></span></code></a>
<a class="link" href="#assertion_expression_anchor"><code class="literal"><span class="emphasis"><em>assertion-expression</em></span></code></a>: <a name="assertion_expression_anchor"></a>
<a class="link" href="#boolean_condition_anchor"><code class="literal"><span class="emphasis"><em>boolean-condition</em></span></code></a> <span class="emphasis"><em>|</em></span>
<span class="identifier">static_assert</span><span class="special">(</span><a class="link" href="#constant_boolean_expression_anchor"><code class="literal"><span class="bold"><strong>constant-boolean-expression</strong></span></code></a><span class="special">,</span> <a class="link" href="#constant_string_literal_anchor"><code class="literal"><span class="bold"><strong>constant-string-literal</strong></span></code></a><span class="special">)</span>
<span class="emphasis"><em>[</em></span><span class="special">,</span> <span class="identifier">requires</span> <a class="link" href="#constant_boolean_expression_anchor"><code class="literal"><span class="bold"><strong>constant-boolean-expression</strong></span></code></a><span class="emphasis"><em>]</em></span>
<a class="link" href="#select_assertion_anchor"><code class="literal"><span class="emphasis"><em>select-assertion</em></span></code></a>: <a name="select_assertion_anchor"></a>
<span class="keyword">if</span><span class="special">(</span><a class="link" href="#boolean_condition_anchor"><code class="literal"><span class="emphasis"><em>boolean-condition</em></span></code></a><span class="special">)</span> <span class="special">(</span> <a class="link" href="#assertion_condition_anchor"><code class="literal"><span class="emphasis"><em>assertion-condition</em></span></code></a><span class="special">,</span> <span class="special">...</span> <span class="special">)</span>
<span class="emphasis"><em>[</em></span><span class="keyword">else</span> <span class="special">(</span> <a class="link" href="#assertion_condition_anchor"><code class="literal"><span class="emphasis"><em>assertion-condition</em></span></code></a><span class="special">,</span> <span class="special">...</span> <span class="special">)</span><span class="emphasis"><em>]</em></span>
<a class="link" href="#boolean_condition_anchor"><code class="literal"><span class="emphasis"><em>boolean-condition</em></span></code></a>: <a name="boolean_condition_anchor"></a>
<a class="link" href="#boolean_expression_anchor"><code class="literal"><span class="bold"><strong>boolean-expression</strong></span></code></a> <span class="emphasis"><em>|</em></span>
<span class="keyword">const</span><span class="special">(</span> <a class="link" href="#inscope_variables_anchor"><code class="literal"><span class="emphasis"><em>inscope-variables</em></span></code></a> <span class="special">)</span> <a class="link" href="#boolean_expression_using_inscope_variables_anchor"><code class="literal"><span class="bold"><strong>boolean-expression-using-inscope-variables</strong></span></code></a>
<a class="link" href="#inscope_variables_anchor"><code class="literal"><span class="emphasis"><em>inscope-variables</em></span></code></a>: <a name="inscope_variables_anchor"></a>
<span class="emphasis"><em>[</em></span><a class="link" href="#wrapped_type_anchor"><code class="literal"><span class="emphasis"><em>wrapped-type</em></span></code></a><span class="emphasis"><em>]</em></span> <a class="link" href="#inscope_variable_anchor"><code class="literal"><span class="bold"><strong>inscope-variable</strong></span></code></a><span class="special">,</span> <span class="special">...</span>
</pre><p>
Some basic name manipulations are allowed at the local scope where the assertions
are being declared in case they are ever needed to simplify the assertion
expressions. Specifically, using-directives, namespace-aliases, and type-definitions
are allowed (these will always affect all assertions within the given preconditions,
postconditions, etc so it is recommended to always use these statement at
the very beginning before the actual assertion conditions). Note that these
name manipulations have no effect on the program run-time state and therefore
they do not compromise the contract constant-correctness requirement.
</p><p>
As indicated by the grammar above, it is not possible to specify assertion
requirements (using <code class="computeroutput"><span class="identifier">requires</span></code>)
for the entire select assertion if-then-else expression. Eventual assertion
requirements must be specified for the single assertions within the select
assertion if-then-else statement and they will never disable compilation
and checking of the select assertion if-condition. Programmers can use the
ternary operator <code class="computeroutput"><span class="special">?:</span></code> instead
of a select assertion if they need to specify a guarded assertion with a
condition that is also disabled by the assertion requirements:
</p><pre class="programlisting"><span class="emphasis"><em>boolean-guard</em></span> <span class="special">?</span> <a class="link" href="#boolean_expression_anchor"><code class="literal"><span class="bold"><strong>boolean-expression</strong></span></code></a> <span class="special">:</span> <span class="keyword">true</span><span class="special">,</span> <span class="identifier">requires</span> <a class="link" href="#constant_boolean_expression_anchor"><code class="literal"><span class="bold"><strong>constant-boolean-expression</strong></span></code></a>
</pre><p>
Constant expressions <code class="computeroutput"><span class="keyword">const</span><span class="special">(</span>
<span class="special">...</span> <span class="special">)</span> </code><code class="literal"><span class="emphasis"><em>expression</em></span></code>
can be used to assert conditions and to check the select assertion if-condition
so to fully enforce the assertion constant-correctness requirement. However,
function arguments, result value, old-of values, and the object <code class="computeroutput"><span class="keyword">this</span></code> are automatically made constant by this
library so constant expressions only need to be used to assert conditions
on global variables, static variables, etc. The type of the in-scope variable
<a class="link" href="#inscope_variable_anchor"><code class="literal"><span class="bold"><strong>inscope-variable</strong></span></code></a>
is optional and it is automatically deduced using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
when it is not specified.
</p></div><div class="section" title="Loop Variants"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.loop_variants"></a><a class="link" href="#contract__.grammar.loop_variants" title="Loop Variants">Loop Variants</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#loop_variant_anchor"><code class="literal"><span class="emphasis"><em>loop-variant</em></span></code></a>: <a name="loop_variant_anchor"></a>
<a class="link" href="#natural_expression_anchor"><code class="literal"><span class="bold"><strong>natural-expression</strong></span></code></a> <span class="emphasis"><em>|</em></span>
<span class="keyword">const</span><span class="special">(</span> <a class="link" href="#inscope_variables_anchor"><code class="literal"><span class="emphasis"><em>inscope-variables</em></span></code></a> <span class="special">)</span> <a class="link" href="#natural_expression_using_inscope_variables_anchor"><code class="literal"><span class="bold"><strong>natural-expression-using-inscope-variables</strong></span></code></a>
</pre><p>
A loop variant must specify a non-negative integral expression that monotonically
decreases at each subsequent loop iteration (the library will automatically
check these two conditions at each loop iteration and terminate the loop
if they are not met by calling the loop variant broken handler). The loop
variant can be specified using a constant-expression <code class="computeroutput"><span class="keyword">const</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
</code><code class="literal"><span class="emphasis"><em>expression</em></span></code> so to fully enforce
the contract constant-correctness requirement.
</p></div><div class="section" title="Named Parameter Declarations"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.named_parameter_declarations"></a><a class="link" href="#contract__.grammar.named_parameter_declarations" title="Named Parameter Declarations">Named
Parameter Declarations</a></h3></div></div></div><pre class="programlisting"><a class="link" href="#named_parameter_declaration_anchor"><code class="literal"><span class="emphasis"><em>named-parameter-declaration</em></span></code></a>: <a name="named_parameter_declaration_anchor"></a>
<span class="emphasis"><em>[</em></span><span class="keyword">namespace</span><span class="special">(</span><a class="link" href="#named_parameter_identifier_namespace_anchor"><code class="literal"><span class="bold"><strong>named-parameter-identifier-namespace</strong></span></code></a><span class="special">)</span><span class="emphasis"><em>]</em></span>
<span class="emphasis"><em>[</em></span><span class="special">(</span><a class="link" href="#named_argument_identifier_anchor"><code class="literal"><span class="bold"><strong>named-argument-identifier</strong></span></code></a><span class="special">)</span><span class="emphasis"><em>]</em></span> <a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a>
</pre></div><div class="section" title="Terminals"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.terminals"></a><a class="link" href="#contract__.grammar.terminals" title="Terminals">Terminals</a></h3></div></div></div><div class="informaltable"><table border="1"><colgroup><col><col><col></colgroup><thead><tr><th>
<p>
Terminal
</p>
</th><th>
<p>
Description
</p>
</th><th>
<p>
If terminal contains unwrapped commas or leading symbols
</p>
</th></tr></thead><tbody><tr><td>
<p>
<a class="link" href="#boolean_expression_anchor"><code class="literal"><span class="bold"><strong>boolean-expression</strong></span></code></a><a name="boolean_expression_anchor"></a>
</p>
</td><td>
<p>
A boolean expression: <code class="computeroutput"><span class="identifier">x</span>
<span class="special">==</span> <span class="number">1</span></code>.
</p>
</td><td>
<p>
Wrap value within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">vey_sizeof</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span>
<span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#boolean_expression_using_inscope_variables_anchor"><code class="literal"><span class="bold"><strong>boolean-expression-using-inscope-variables</strong></span></code></a><a name="boolean_expression_using_inscope_variables_anchor"></a>
</p>
</td><td>
<p>
A boolean expression that only uses in-scope variables captured
as constants by a constant expression <code class="computeroutput"><span class="keyword">const</span><span class="special">(</span> <span class="special">...</span>
<span class="special">)</span> </code><code class="literal"><span class="emphasis"><em>expression</em></span></code>.
</p>
</td><td>
<p>
Wrap value within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">key_sizeof</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span>
<span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">+</span>
<span class="identifier">x</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#boost_concept_anchor"><code class="literal"><span class="bold"><strong>boost-concept</strong></span></code></a><a name="boost_concept_anchor"></a>
</p>
</td><td>
<p>
A concept class defined using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/concept_check" target="_top">Boost.ConceptCheck</a>:
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">CopyConstructible</span></code>.
</p>
</td><td>
<p>
Wrap type within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
<span class="keyword">int</span><span class="special">&gt;)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#catch_declaration_anchor"><code class="literal"><span class="bold"><strong>catch-declaration</strong></span></code></a><a name="catch_declaration_anchor"></a>
</p>
</td><td>
<p>
The declaration of an exception for a <code class="computeroutput"><span class="keyword">catch</span></code>
statement: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span><span class="special">&amp;</span> <span class="identifier">error</span></code>.
</p>
</td><td>
<p>
Wrap type using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>:
<code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">exception</span><span class="special">&amp;))</span> <span class="identifier">error</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#catch_instructions_anchor"><code class="literal"><span class="bold"><strong>catch-instructions</strong></span></code></a><a name="catch_instructions_anchor"></a>
</p>
</td><td>
<p>
The instructions of a <code class="computeroutput"><span class="keyword">catch</span></code>
statement terminated by semicolons <code class="computeroutput"><span class="special">;</span></code>:
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span>
<span class="string">"error"</span> <span class="special">&lt;&lt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="identifier">exit</span><span class="special">(</span><span class="number">255</span><span class="special">);</span></code>.
</p>
</td><td>
<p>
Wrap types using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>
and values within parenthesis: <code class="computeroutput"><span class="keyword">typedef</span>
<span class="identifier">BOOST_UTILITY_TYPE</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span>
<span class="keyword">int</span><span class="special">&gt;)</span>
<span class="identifier">mtype</span><span class="special">;</span>
<span class="special">(</span><span class="identifier">mtype</span>
<span class="identifier">m</span><span class="special">,</span>
<span class="identifier">m</span><span class="special">[</span><span class="char">'a'</span><span class="special">]</span> <span class="special">=</span> <span class="number">1</span><span class="special">);</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#class_name_anchor"><code class="literal"><span class="bold"><strong>class-name</strong></span></code></a><a name="class_name_anchor"></a>
</p>
</td><td>
<p>
The class name: <code class="computeroutput"><span class="identifier">myclass</span></code>.
For class templates this must not include the template instantiation
parameters: <code class="computeroutput"><span class="identifier">vector</span></code>.
(For non-template classes, the class type and name are the same.)
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#class_type_anchor"><code class="literal"><span class="bold"><strong>class-type</strong></span></code></a><a name="class_type_anchor"></a>
</p>
</td><td>
<p>
The class type, for class templates this must include the template
instantiation parameters: <code class="computeroutput"><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>.
</p>
</td><td>
<p>
Wrap type within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span>
<span class="identifier">T</span><span class="special">&gt;)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#constant_boolean_expression_anchor"><code class="literal"><span class="bold"><strong>constant-boolean-expression</strong></span></code></a><a name="constant_boolean_expression_anchor"></a>
</p>
</td><td>
<p>
A compile-time constant boolean expression: <code class="computeroutput"><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">&gt;=</span>
<span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>.
</p>
</td><td>
<p>
Wrap value within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
<span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#constant_string_literal_anchor"><code class="literal"><span class="bold"><strong>constant-string-literal</strong></span></code></a><a name="constant_string_literal_anchor"></a>
</p>
</td><td>
<p>
A compile-time constant string literal: <code class="computeroutput"><span class="string">"abc"</span></code>.
</p>
</td><td>
<p>
Do nothing: <code class="computeroutput"><span class="string">"abc"</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#exception_type_anchor"><code class="literal"><span class="bold"><strong>exception-type</strong></span></code></a><a name="exception_type_anchor"></a>
</p>
</td><td>
<p>
A type: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span></code>, <code class="computeroutput"><span class="keyword">int</span></code>,
<code class="computeroutput"><span class="identifier">mytype</span></code>.
</p>
</td><td>
<p>
Wrap type within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span>
<span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">exception</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#function_identifier_anchor"><code class="literal"><span class="bold"><strong>function-identifier</strong></span></code></a><a name="function_identifier_anchor"></a>
</p>
</td><td>
<p>
A valid function name identifier (C++ requires it to be alphanumeric):
<code class="computeroutput"><span class="identifier">f</span></code>, <code class="computeroutput"><span class="identifier">push_back</span></code>, <code class="computeroutput"><span class="identifier">myfunc</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#inscope_variable_anchor"><code class="literal"><span class="bold"><strong>inscope-variable</strong></span></code></a><a name="inscope_variable_anchor"></a>
</p>
</td><td>
<p>
A variable in-scope.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#loop_declaration_anchor"><code class="literal"><span class="bold"><strong>loop-declaration</strong></span></code></a><a name="loop_declaration_anchor"></a>
</p>
</td><td>
<p>
A loop declaration: <code class="computeroutput"><span class="keyword">for</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span>
<span class="number">0</span><span class="special">;</span>
<span class="identifier">i</span> <span class="special">&lt;</span>
<span class="number">10</span><span class="special">;</span>
<span class="special">++</span><span class="identifier">i</span><span class="special">)</span></code>, <code class="computeroutput"><span class="keyword">while</span><span class="special">(</span><span class="identifier">i</span>
<span class="special">&lt;</span> <span class="number">10</span><span class="special">)</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#member_initializer_anchor"><code class="literal"><span class="bold"><strong>member-initializer</strong></span></code></a><a name="member_initializer_anchor"></a>
</p>
</td><td>
<p>
A member initialization expression: <code class="computeroutput"><span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span></code>.
</p>
</td><td>
<p>
Wrap object initializations within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">base_map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span>
<span class="keyword">int</span><span class="special">&gt;())</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#named_argument_identifier_anchor"><code class="literal"><span class="bold"><strong>named-argument-identifier</strong></span></code></a><a name="named_argument_identifier_anchor"></a>
</p>
</td><td>
<p>
The argument name to use at the calling site to pass named and
deduced parameter values: <code class="computeroutput"><span class="identifier">value_arg</span></code>,
<code class="computeroutput"><span class="identifier">NumberArg</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#named_parameter_identifier_namespace_anchor"><code class="literal"><span class="bold"><strong>named-parameter-identifier-namespace</strong></span></code></a><a name="named_parameter_identifier_namespace_anchor"></a>
</p>
</td><td>
<p>
The internal namespace for named and deduced parameter identifiers:
<code class="computeroutput"><span class="identifier">params</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#namespace_alias_anchor"><code class="literal"><span class="bold"><strong>namespace-alias</strong></span></code></a><a name="namespace_alias_anchor"></a>
</p>
</td><td>
<p>
The argument to pass to namespace aliasing: <code class="computeroutput"><span class="identifier">mpl</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#natural_expression_anchor"><code class="literal"><span class="bold"><strong>natural-expression</strong></span></code></a><a name="natural_expression_anchor"></a>
</p>
</td><td>
<p>
A natural (i.e., non-negative integral) expression: <code class="computeroutput"><span class="number">2</span> <span class="special">-</span> <span class="number">1</span></code>.
</p>
</td><td>
<p>
Wrap value within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">key_sizeof</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span>
<span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#natural_expression_using_inscope_variables_anchor"><code class="literal"><span class="bold"><strong>natural-expression-using-inscope-variables</strong></span></code></a><a name="natural_expression_using_inscope_variables_anchor"></a>
</p>
</td><td>
<p>
A natural (i.e., non-negative integral) expression that only uses
in-scope variables captured as constant by a constant-expression:
<code class="computeroutput"><span class="identifier">x</span> <span class="special">+</span>
<span class="number">10</span></code>.
</p>
</td><td>
<p>
Wrap value within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">key_sizeof</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span>
<span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">+</span>
<span class="identifier">x</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#new_type_name_anchor"><code class="literal"><span class="bold"><strong>new-type-name</strong></span></code></a><a name="new_type_name_anchor"></a>
</p>
</td><td>
<p>
A new type name for <code class="computeroutput"><span class="keyword">typedef</span></code>
statement: <code class="computeroutput"><span class="identifier">myint</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#oldof_expression_anchor"><code class="literal"><span class="bold"><strong>oldof-expression</strong></span></code></a><a name="oldof_expression_anchor"></a>
</p>
</td><td>
<p>
A expression of type <a class="link" href="#contract__.advanced_topics.old_and_result_value_copies" title="Old and Result Value Copies"><code class="literal">ConstantCopyConstructible</code></a>
to pass to the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code>
macro: <code class="computeroutput"><span class="identifier">value</span></code>,
<code class="computeroutput"><span class="identifier">size</span><span class="special">()</span></code>.
</p>
</td><td>
<p>
Wrap value within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">x</span><span class="special">,</span>
<span class="identifier">y</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#operator_identifier_anchor"><code class="literal"><span class="bold"><strong>operator-identifier</strong></span></code></a><a name="operator_identifier_anchor"></a>
</p>
</td><td>
<p>
An arbitrary but alphanumeric identifier: <code class="computeroutput"><span class="identifier">equal</span></code>,
<code class="computeroutput"><span class="identifier">less</span></code>, <code class="computeroutput"><span class="identifier">call</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#operator_symbol_anchor"><code class="literal"><span class="bold"><strong>operator-symbol</strong></span></code></a><a name="operator_symbol_anchor"></a>
</p>
</td><td>
<p>
The usual operator symbols: <code class="computeroutput"><span class="special">==</span></code>,
<code class="computeroutput"><span class="special">&lt;=</span></code>, <code class="computeroutput"><span class="special">()</span></code>.
</p>
</td><td>
<p>
Do nothing: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#parameter_default_anchor"><code class="literal"><span class="bold"><strong>parameter-default</strong></span></code></a><a name="parameter_default_anchor"></a>
</p>
</td><td>
<p>
A function or template parameter default value (either a value,
a type, or a template depending on the kind of parameter): <code class="computeroutput"><span class="number">123</span></code>.
</p>
</td><td>
<p>
Wrap value within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="string">"abc"</span><span class="special">)</span></code>,
<code class="computeroutput"><span class="special">(</span><span class="char">'a'</span><span class="special">)</span></code>, <code class="computeroutput"><span class="special">(-</span><span class="number">123</span><span class="special">)</span></code>,
<code class="computeroutput"><span class="special">(</span><span class="number">1.23</span><span class="special">)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#parameter_name_anchor"><code class="literal"><span class="bold"><strong>parameter-name</strong></span></code></a><a name="parameter_name_anchor"></a>
</p>
</td><td>
<p>
A function or template parameter name: <code class="computeroutput"><span class="identifier">value</span></code>,
<code class="computeroutput"><span class="identifier">T</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#template_parameter_anchor"><code class="literal"><span class="bold"><strong>template-parameter</strong></span></code></a><a name="template_parameter_anchor"></a>
</p>
</td><td>
<p>
A usual C++ type template parameter, value template parameter,
or template template parameter): <code class="computeroutput"><span class="keyword">typename</span>
<span class="identifier">T</span></code>, <code class="computeroutput"><span class="keyword">class</span>
<span class="identifier">U</span></code>, <code class="computeroutput"><span class="keyword">int</span>
<span class="identifier">Number</span></code>, <code class="computeroutput"><span class="identifier">T</span> <span class="identifier">Value</span></code>,
<code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">typename</span> <span class="identifier">X</span><span class="special">,</span> <span class="keyword">class</span>
<span class="identifier">Y</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">Template</span></code>.
</p>
</td><td>
<p>
Do nothing: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">Default</span></code>,
<code class="computeroutput"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">typename</span> <span class="identifier">X</span><span class="special">,</span> <span class="keyword">class</span>
<span class="identifier">Y</span> <span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">Template</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#template_specialization_anchor"><code class="literal"><span class="bold"><strong>template-specialization</strong></span></code></a><a name="template_specialization_anchor"></a>
</p>
</td><td>
<p>
A template specialization argument (type, value, etc) that follow
the class name in the declaration to specialize a template: <code class="computeroutput"><span class="keyword">void</span> <span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">)</span></code>.
</p>
</td><td>
<p>
Wrap types within parenthesis: <code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span>
<span class="keyword">int</span><span class="special">&gt;)</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#type_anchor"><code class="literal"><span class="bold"><strong>type</strong></span></code></a><a name="type_anchor"></a>
</p>
</td><td>
<p>
A type: <code class="computeroutput"><span class="keyword">int</span></code>, <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span></code>, <code class="computeroutput"><span class="identifier">mytype</span></code>.
</p>
</td><td>
<p>
Do nothing: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#typedef_type_anchor"><code class="literal"><span class="bold"><strong>typedef-type</strong></span></code></a><a name="typedef_type_anchor"></a>
</p>
</td><td>
<p>
A type: <code class="computeroutput"><span class="keyword">int</span></code>, <code class="computeroutput"><span class="identifier">mytype</span></code>.
</p>
</td><td>
<p>
Wrap type using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>:
<code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;))</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#unary_boolean_metafunction_anchor"><code class="literal"><span class="bold"><strong>unary-boolean-metafunction</strong></span></code></a><a name="unary_boolean_metafunction_anchor"></a>
</p>
</td><td>
<p>
A boolean meta-function that takes one parameter: <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_class</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">&gt;</span></code>.
</p>
</td><td>
<p>
Do nothing: <code class="computeroutput"><span class="identifier">boost</span><span class="special">:</span><span class="identifier">is_convertible</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">_</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span></code>.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#using_directive_anchor"><code class="literal"><span class="bold"><strong>using-directive</strong></span></code></a><a name="using_directive_anchor"></a>
</p>
</td><td>
<p>
The argument to pass to a using directive: <code class="computeroutput"><span class="keyword">namespace</span>
<span class="identifier">std</span></code>, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr><tr><td>
<p>
<a class="link" href="#variable_name_anchor"><code class="literal"><span class="bold"><strong>variable-name</strong></span></code></a><a name="variable_name_anchor"></a>
</p>
</td><td>
<p>
A valid name to use to declare a variable: <code class="computeroutput"><span class="identifier">result</span></code>,
<code class="computeroutput"><span class="identifier">old_size</span></code>.
</p>
</td><td>
<p>
Never the case.
</p>
</td></tr></tbody></table></div><p>
If terminals contain commas not already wrapped by round parenthesis or if
they start with a non-alphanumeric symbol (including tokens like <code class="computeroutput"><span class="char">'a'</span></code>, <code class="computeroutput"><span class="string">"abc"</span></code>,
<code class="computeroutput"><span class="special">-</span><span class="number">123</span></code>,
and <code class="computeroutput"><span class="number">1.23</span></code>), <sup>[<a name="contract__.grammar.terminals.f0" href="#ftn.contract__.grammar.terminals.f0" class="footnote">71</a>]</sup> they need to be wrapped by extra round parenthesis <code class="computeroutput"><span class="special">(...)</span></code> or by the <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>
<code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((...))</span></code>
macro. Value expressions can always be wrapped within extra around parenthesis
in C++. Type expressions can always be wrapped using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/identity_type" target="_top">Boost.Utility/IdentityType</a>
but that will make the syntax less readable (and it prevents C++ from automatically
deducing function template parameters) so this syntax allows to wrap type
expressions within extra round parenthesis <code class="computeroutput"><span class="special">(...)</span></code>
for most terminals, including types, as indicated by the table above.
</p></div><div class="section" title="Alternative Assertion Syntax (Not Implemented)"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.grammar.alternative_assertion_syntax__not_implemented_"></a><a class="link" href="#contract__.grammar.alternative_assertion_syntax__not_implemented_" title="Alternative Assertion Syntax (Not Implemented)">Alternative
Assertion Syntax (Not Implemented)</a></h3></div></div></div><p>
The following alternative syntax could have been implemented to program the
contract assertions:
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
This Library Syntax
</p>
</th><th>
<p>
Alternative Syntax (not implemented)
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">vector</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="special">...</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">erase</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">where</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="keyword">not</span> <span class="identifier">empty</span><span class="special">(),</span>
<span class="identifier">where</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">static_assert</span><span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">&gt;=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">int</span><span class="special">),</span> <span class="string">"large enough"</span><span class="special">)</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">-</span> <span class="number">1</span><span class="special">,</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">const</span><span class="special">(</span> <span class="keyword">this</span> <span class="special">)</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">empty</span><span class="special">())</span> <span class="special">(</span>
<span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">};</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">vector</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="special">...</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="special">(</span><span class="identifier">erase</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="identifier">where</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="identifier">assert</span><span class="special">(</span><span class="keyword">not</span> <span class="identifier">empty</span><span class="special">())</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">where</span> <span class="special">!=</span> <span class="identifier">end</span><span class="special">())</span>
<span class="identifier">static_assert</span><span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">&gt;=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">int</span><span class="special">),</span> <span class="string">"large enough"</span><span class="special">)</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">decl</span><span class="special">(</span><span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">)</span>
<span class="identifier">decl</span><span class="special">(</span><span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">())</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">-</span> <span class="number">1</span><span class="special">)</span>
<span class="keyword">if</span><span class="special">(</span><span class="keyword">const</span><span class="special">(</span><span class="keyword">this</span><span class="special">,</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">empty</span><span class="special">()))</span> <span class="special">(</span>
<span class="identifier">assert</span><span class="special">(</span><span class="identifier">result</span> <span class="special">==</span> <span class="identifier">end</span><span class="special">())</span>
<span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="keyword">return</span> <span class="identifier">vector_</span><span class="special">.</span><span class="identifier">erase</span><span class="special">();</span>
<span class="special">}</span>
<span class="special">};</span>
</pre><p>
</p>
</td></tr></tbody></table></div><p>
An advantage of this alternative syntax is that it does not require commas
at the end of each assertion. However, when compared with this library syntax,
the alternative syntax is overall more verbose, it uses more parenthesis,
it deviates more from <a class="link" href="#N1962_anchor">[N1962]</a> and <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
(even if it is more similar to <a class="ulink" href="http://dlang.org" target="_top">D</a>),
and it looks less readable at least because of <code class="computeroutput"><span class="identifier">decl</span><span class="special">(...)</span></code> (in many ways this alternative syntax
is equivalent to the already supported sequencing syntax from the <a class="link" href="#contract__.no_variadic_macros" title="No Variadic Macros">No
Variadic Macros</a> section with the addition of <span class="quote">&#8220;<span class="quote">decoration identifiers</span>&#8221;</span>
like <code class="computeroutput"><span class="identifier">assert</span></code>, <code class="computeroutput"><span class="identifier">decl</span></code>, etc which might make the code more
readable but are not needed syntactically). Therefore, the authors opted
for implementing the syntax on the left hand side.
</p></div></div><div class="section" title="No Variadic Macros"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.no_variadic_macros"></a><a class="link" href="#contract__.no_variadic_macros" title="No Variadic Macros">No Variadic Macros</a></h2></div></div></div><p>
This section illustrates an alternative syntax, the <span class="emphasis"><em>sequence syntax</em></span>,
that can be used on compilers that do not support variadic macros. Most modern
compilers support <a class="ulink" href="http://en.wikipedia.org/wiki/Variadic_macro" target="_top">variadic
macros</a> (notably, these include GCC, MSVC, and all <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
compilers).
</p><div class="warning" title="Warning"><table border="0" summary="Warning"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../doc/src/images/warning.png"></td><th align="left">Warning</th></tr><tr><td align="left" valign="top"><p>
The sequence syntax presented in this section has not been fully tested yet.
Future revisions of the library are expected to test and support the sequence
syntax more thoroughly (see also <a class="ulink" href="https://sourceforge.net/apps/trac/contractpp/ticket/58" target="_top">Ticket
58</a>).
</p></td></tr></table></div><p>
The sequence syntax uses many extra parenthesis and it is significantly less
readable than the comma-separated syntax that we have seen so far. Therefore,
it is strongly recommended to not use the sequence syntax unless it is absolutely
necessary to program contracts that are portable to compilers that do not support
variadic macros.
</p><div class="section" title="Sequence Syntax"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.no_variadic_macros.sequence_syntax"></a><a class="link" href="#contract__.no_variadic_macros.sequence_syntax" title="Sequence Syntax">Sequence
Syntax</a></h3></div></div></div><p>
In the rare case that programmers need to use this library on compliers without
variadic macros, this library also allows to specify its macro parameters
using a <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/preprocessor" target="_top">Boost.Preprocessor</a>
sequence in which tokens are separated using round parenthesis <code class="computeroutput"><span class="special">()</span></code>:
</p><pre class="programlisting"><span class="special">(</span><span class="identifier">token1</span><span class="special">)</span> <span class="special">(</span><span class="identifier">token2</span><span class="special">)</span> <span class="special">...</span> <span class="comment">// All compilers.</span>
</pre><p>
Instead of the comma-separated lists that we have seen so far which require
variadic macros:
</p><pre class="programlisting"><span class="identifier">token1</span><span class="special">,</span> <span class="identifier">token2</span><span class="special">,</span> <span class="special">...</span> <span class="comment">// Only compilers with variadic macros (preferred).</span>
</pre><p>
This library detects preprocessor support for variadic macros using the
<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/config" target="_top">Boost.Config</a>
macro <code class="computeroutput"><span class="identifier">BOOST_NO_VARIADIC_MACROS</span></code>.
<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/config" target="_top">Boost.Config</a>
defines the <code class="computeroutput"><span class="identifier">BOOST_NO_VARIADIC_MACROS</span></code>
only on compilers that do not support variadic macros furthermore programmers
can forcefully define this macro also on compilers that support variadic
macros. When this macro is not defined, this library macros support both
the camma-separated and sequence syntax, otherwise only the sequence syntax
is supported.
</p><div class="note" title="Note"><table border="0" summary="Note"><tr><td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../doc/src/images/note.png"></td><th align="left">Note</th></tr><tr><td align="left" valign="top"><p>
The same macros accept both syntaxes on compilers with variadic macros
and only the sequence syntax on compilers without variadic macros.
</p></td></tr></table></div><p>
For example, the syntax on the left hand side works on all compilers with
and without variaidic macros (see also <a class="ulink" href="../../example/contracts/class_template_vector_seq.cpp" target="_top"><code class="literal">class_template_vector_seq.cpp</code></a>,
<a class="ulink" href="../../example/contracts/pushable_seq.hpp" target="_top"><code class="literal">pushable_seq.hpp</code></a>, <a class="ulink" href="../../example/contracts/class_template_vector.cpp" target="_top"><code class="literal">class_template_vector.cpp</code></a>,
and <a class="ulink" href="../../example/contracts/pushable.hpp" target="_top"><code class="literal">pushable.hpp</code></a>):
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
Sequence Syntax (all compilers)
</p>
</th><th>
<p>
Comma-Separated Syntax (variadic macros only, preferred)
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="special">(</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">)</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">pushable</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Subcontracting: In `and` with derived class invariants.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">((</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span><span class="special">)</span> <span class="special">)</span> <span class="keyword">new</span>
<span class="comment">// Subcontracting: In `or` with overriding function preconditions.</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="special">(</span><span class="keyword">false</span><span class="special">)</span> <span class="special">)</span> <span class="comment">// Force check to overriding preconditions.</span>
<span class="comment">// Subcontracting: In `and` with overriding function postconditions.</span>
<span class="identifier">postcondition</span><span class="special">(</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="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Contract for pure virtual function.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">virtual</span> <span class="identifier">const_reference</span> <span class="identifier">back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">pushable</span><span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Subcontracting: In `and` with derived class invariants.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span> <span class="keyword">new</span>
<span class="comment">// Subcontracting: In `or` with overriding function preconditions.</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="keyword">false</span> <span class="special">)</span> <span class="comment">// Force check to overriding preconditions.</span>
<span class="comment">// Subcontracting: In `and` with overriding function postconditions.</span>
<span class="identifier">postcondition</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="identifier">requires</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Contract for pure virtual function.</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">virtual</span> <span class="identifier">const_reference</span> <span class="identifier">back</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">};</span>
</pre><p>
</p>
</td></tr><tr><td>
<p>
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="string">"pushable_seq.hpp"</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span> <span class="special">(</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">)</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="special">(</span><span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Use preprocessor sequences instead of variadic comma-separated lists.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="special">(</span><span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">))</span>
<span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">())</span>
<span class="special">(</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">())</span>
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">()))</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span> <span class="identifier">const_iterator</span><span class="special">;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">((</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="special">(</span><span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</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">size</span><span class="special">()</span> <span class="special">==</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">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">T</span><span class="special">()))</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="special">(</span><span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">))</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">((</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</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">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">())</span>
<span class="special">(</span><span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</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">old_size</span> <span class="special">+</span> <span class="number">1</span><span class="special">)</span>
<span class="special">(</span><span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span><span class="special">)</span>
<span class="comment">// Overridden postconditions also check `back() == value`.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</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><td>
<p>
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="string">"pushable.hpp"</span>
<span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<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="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">)</span> <span class="comment">// Subcontract.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="comment">// Within templates, use contract macros postfixed by `_TPL`.</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="identifier">empty</span><span class="special">()</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">0</span><span class="special">),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&lt;=</span> <span class="identifier">max_size</span><span class="special">(),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span> <span class="special">==</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">size</span><span class="special">())</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">size_type</span> <span class="identifier">size_type</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_reference</span> <span class="identifier">const_reference</span><span class="special">;</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">const_iterator</span> <span class="identifier">const_iterator</span><span class="special">;</span>
<span class="identifier">CONTRACT_CONSTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">explicit</span> <span class="special">(</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">count</span> <span class="special">&gt;=</span> <span class="number">0</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">count</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">algorithm</span><span class="special">::</span><span class="identifier">all_of_equal</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">(),</span> <span class="identifier">T</span><span class="special">())</span>
<span class="special">)</span>
<span class="identifier">initialize</span><span class="special">(</span> <span class="identifier">vector_</span><span class="special">(</span><span class="identifier">count</span><span class="special">)</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_DESTRUCTOR_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">virtual</span> <span class="special">(~</span><span class="identifier">vector</span><span class="special">)</span> <span class="special">(</span> <span class="keyword">void</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{}</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">void</span> <span class="special">(</span><span class="identifier">push_back</span><span class="special">)</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">value</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="identifier">size</span><span class="special">()</span> <span class="special">&lt;</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span>
<span class="keyword">auto</span> <span class="identifier">old_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="keyword">auto</span> <span class="identifier">old_capacity</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">capacity</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_size</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span>
<span class="identifier">capacity</span><span class="special">()</span> <span class="special">&gt;=</span> <span class="identifier">old_capacity</span>
<span class="comment">// Overridden postconditions also check `back() == value`.</span>
<span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">vector_</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>
Note the many extra parenthesis around all tokens within the lists: template
parameters <code class="computeroutput"><span class="special">(</span><span class="keyword">typename</span>
<span class="identifier">T</span><span class="special">)</span></code>,
base classes <code class="computeroutput"><span class="special">(</span><span class="keyword">public</span>
<span class="identifier">pushable</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;)</span></code>,
function parameters <code class="computeroutput"><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="identifier">count</span></code>,
all assertions, etc. Furthermore, empty lists need to be specified using
<code class="computeroutput"><span class="special">(</span><span class="keyword">void</span><span class="special">)</span></code> instead of just <code class="computeroutput"><span class="keyword">void</span></code>.
</p><p>
When using the sequence syntax, the macro <code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_OLDOFS" title="Macro CONTRACT_LIMIT_OLDOFS">CONTRACT_LIMIT_OLDOFS</a></code>
specifies the maximum number of postconditions sequence elements (instead
of the maximum possible number of old value declarations as for variadic
macros).
</p></div><div class="section" title="Commas and Leading Symbols in Macros"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.no_variadic_macros.commas_and_leading_symbols_in_macros"></a><a class="link" href="#contract__.no_variadic_macros.commas_and_leading_symbols_in_macros" title="Commas and Leading Symbols in Macros">Commas
and Leading Symbols in Macros</a></h3></div></div></div><p>
As we have seen in the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section, syntactic elements containing unwrapped commas and
leading symbols need to be wrapped within extra round parenthesis:
</p><pre class="programlisting"><span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="special">&gt;)</span> <span class="comment">// With variadic macros.</span>
</pre><p>
However, without variadic macros this is no longer sufficient and the number
of commas needs to be explicitly specified using the following syntax: <sup>[<a name="contract__.no_variadic_macros.commas_and_leading_symbols_in_macros.f0" href="#ftn.contract__.no_variadic_macros.commas_and_leading_symbols_in_macros.f0" class="footnote">72</a>]</sup>
</p><pre class="programlisting"><span class="identifier">comma</span><span class="special">(</span><span class="number">2</span><span class="special">)(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&gt;</span> <span class="special">&gt;)</span> <span class="comment">// Without variadic macros.</span>
</pre><p>
For example (see also <a class="ulink" href="../../example/contracts/macro_commas_symbols_integral_map_seq.cpp" target="_top"><code class="literal">macro_commas_symbols_integral_map_seq.cpp</code></a> and
<a class="ulink" href="../../example/contracts/macro_commas_symbols_integral_map.cpp" target="_top"><code class="literal">macro_commas_symbols_integral_map.cpp</code></a>):
</p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><thead><tr><th>
<p>
Sequence Syntax (all compilers)
</p>
</th><th>
<p>
Comma-Separated Syntax (variadic macros only, preferred)
</p>
</th></tr></thead><tbody><tr><td>
<p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">Key</span><span class="special">)</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">)</span>
<span class="special">(</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">)</span>
<span class="special">(</span><span class="keyword">default</span> <span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;))</span>
<span class="special">(</span><span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(</span><span class="keyword">typename</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">key_type</span><span class="special">)</span> <span class="identifier">default_key</span><span class="special">)</span>
<span class="special">(</span><span class="keyword">default</span> <span class="special">(-</span><span class="number">1</span><span class="special">))</span>
<span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <span class="special">(</span><span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;))</span> <span class="special">)</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">integral_map</span><span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="special">(</span><span class="keyword">public</span> <span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;))</span> <span class="special">)</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span>
<span class="special">(((::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_size</span><span class="special">))</span> <span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">())</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span>
<span class="identifier">iterator</span> <span class="identifier">iterator</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="special">(</span><span class="keyword">typename</span> <span class="identifier">OtherKey</span><span class="special">)</span> <span class="special">(</span><span class="keyword">typename</span> <span class="identifier">OtherT</span><span class="special">)</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="special">(</span><span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">Key</span><span class="special">&gt;))</span>
<span class="special">(</span><span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">OtherT</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;))</span>
<span class="special">)</span>
<span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&gt;)</span> <span class="special">(</span><span class="identifier">insert</span><span class="special">)</span> <span class="special">(</span>
<span class="special">(</span><span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">other_value</span><span class="special">)</span>
<span class="special">(</span><span class="keyword">default</span> <span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span><span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">default_key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">())))</span>
<span class="special">)</span> <span class="keyword">throw</span><span class="special">(</span> <span class="special">(</span><span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;))</span> <span class="special">)</span>
<span class="identifier">precondition</span><span class="special">(</span>
<span class="special">((!</span><span class="identifier">full</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">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">)</span>
<span class="special">(</span><span class="identifier">comma</span><span class="special">(</span><span class="number">1</span><span class="special">)(</span><span class="keyword">typename</span> <span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;::</span><span class="identifier">size_type</span><span class="special">)</span>
<span class="identifier">old_other_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span>
<span class="special">(</span><span class="identifier">size</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;()))</span>
<span class="special">(((::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_size</span><span class="special">))</span> <span class="special">&gt;=</span> <span class="identifier">size</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">old_other_size</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">result</span><span class="special">.</span><span class="identifier">second</span> <span class="special">?</span> <span class="number">1</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="comment">// ...</span>
</pre><p>
</p>
</td><td>
<p>
</p><pre class="programlisting"><span class="identifier">CONTRACT_CLASS</span><span class="special">(</span>
<span class="keyword">template</span><span class="special">(</span>
<span class="keyword">typename</span> <span class="identifier">Key</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="comment">// Commas in following template params.</span>
<span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">,</span>
<span class="keyword">default</span> <span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">allocator</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;),</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="special">::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">key_type</span><span class="special">)</span> <span class="identifier">default_key</span><span class="special">,</span>
<span class="keyword">default</span> <span class="special">(-</span><span class="number">1</span><span class="special">)</span>
<span class="special">)</span> <span class="identifier">requires</span><span class="special">(</span> <span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;)</span> <span class="special">)</span> <span class="comment">// Commas in concepts.</span>
<span class="keyword">class</span> <span class="special">(</span><span class="identifier">integral_map</span><span class="special">)</span>
<span class="identifier">extends</span><span class="special">(</span> <span class="keyword">public</span> <span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span> <span class="special">)</span> <span class="comment">// Commas in bases.</span>
<span class="special">)</span> <span class="special">{</span>
<span class="identifier">CONTRACT_CLASS_INVARIANT_TPL</span><span class="special">(</span> <span class="comment">// Commas in class invariants.</span>
<span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_size</span><span class="special">)</span> <span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">()</span>
<span class="special">)</span>
<span class="keyword">public</span><span class="special">:</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;,</span> <span class="identifier">Allocator</span><span class="special">&gt;::</span>
<span class="identifier">iterator</span> <span class="identifier">iterator</span><span class="special">;</span>
<span class="identifier">CONTRACT_FUNCTION_TPL</span><span class="special">(</span>
<span class="keyword">public</span> <span class="keyword">template</span><span class="special">(</span> <span class="keyword">typename</span> <span class="identifier">OtherKey</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OtherT</span> <span class="special">)</span>
<span class="identifier">requires</span><span class="special">(</span>
<span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">Key</span><span class="special">&gt;),</span>
<span class="special">(::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">Convertible</span><span class="special">&lt;</span><span class="identifier">OtherT</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span>
<span class="special">)</span>
<span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span><span class="special">&gt;)</span> <span class="special">(</span><span class="identifier">insert</span><span class="special">)</span> <span class="special">(</span> <span class="comment">// Commas in result and params.</span>
<span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span> <span class="identifier">other_value</span><span class="special">,</span>
<span class="keyword">default</span> <span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;(</span><span class="identifier">default_key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">()))</span>
<span class="special">)</span> <span class="keyword">throw</span><span class="special">(</span> <span class="special">(::</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;)</span> <span class="special">)</span> <span class="comment">// Commas in exception specs.</span>
<span class="identifier">precondition</span><span class="special">(</span> <span class="comment">// Leading symbols in preconditions (same for commas).</span>
<span class="special">((!</span><span class="identifier">full</span><span class="special">()))</span> <span class="comment">// LIMITATION: Two sets `((...))` (otherwise seq.).</span>
<span class="special">)</span>
<span class="identifier">postcondition</span><span class="special">(</span> <span class="comment">// Commas in postconditions.</span>
<span class="keyword">auto</span> <span class="identifier">result</span> <span class="special">=</span> <span class="keyword">return</span><span class="special">,</span>
<span class="special">(</span><span class="keyword">typename</span> <span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;::</span><span class="identifier">size_type</span><span class="special">)</span>
<span class="identifier">old_other_size</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span>
<span class="special">(</span><span class="identifier">size</span><span class="special">&lt;</span><span class="identifier">OtherKey</span><span class="special">,</span> <span class="identifier">OtherT</span><span class="special">&gt;()),</span>
<span class="special">(::</span><span class="identifier">sizeable</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">max_size</span><span class="special">)</span> <span class="special">&gt;=</span> <span class="identifier">size</span><span class="special">(),</span>
<span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">old_other_size</span> <span class="special">+</span> <span class="special">(</span><span class="identifier">result</span><span class="special">.</span><span class="identifier">second</span> <span class="special">?</span> <span class="number">1</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="comment">// ...</span>
</pre><p>
</p>
</td></tr></tbody></table></div></div></div><div class="section" title="Reference"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="reference"></a>Reference</h2></div></div></div><div class="section" title="Header &lt;contract/block_invariant.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.block_invariant_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/block_invariant.hpp" target="_top">contract/block_invariant.hpp</a>&gt;</h3></div></div></div><p>Macros used to specify block invariants (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_BLOCK_INVARIANT" title="Macro CONTRACT_BLOCK_INVARIANT">CONTRACT_BLOCK_INVARIANT</a>(assertions)
<a class="link" href="#CONTRACT_BLOCK_INVARIANT_TPL" title="Macro CONTRACT_BLOCK_INVARIANT_TPL">CONTRACT_BLOCK_INVARIANT_TPL</a>(assertions)</pre><div class="refentry" title="Macro CONTRACT_BLOCK_INVARIANT"><a name="CONTRACT_BLOCK_INVARIANT"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_BLOCK_INVARIANT</span></h2><p>CONTRACT_BLOCK_INVARIANT &#8212; Macro used to specify block invariants. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.block_invariant_hpp" title="Header &lt;contract/block_invariant.hpp&gt;">contract/block_invariant.hpp</a>&gt;
</span>CONTRACT_BLOCK_INVARIANT(assertions)</pre></div><div class="refsect1" title="Description"><a name="id717417"></a><h2>Description</h2><p>This macro can appear at any point in a code block within a function definition and it is used to assert correctness condition of the implementation (similarly to C++ <code class="computeroutput">assert</code>).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">assertions</code></strong></span></td><td>The syntax for the assertions is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. Static assertions, constant assertions, and select assertions can be used. </td></tr></tbody></table></div><p>
</p><p>Within a type-dependent scope (e.g., within templates), <code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT_TPL" title="Macro CONTRACT_BLOCK_INVARIANT_TPL">CONTRACT_BLOCK_INVARIANT_TPL</a></code> must be used instead of this macro.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_BLOCK_INVARIANT_TPL"><div class="refentry.separator"><hr></div><a name="CONTRACT_BLOCK_INVARIANT_TPL"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_BLOCK_INVARIANT_TPL</span></h2><p>CONTRACT_BLOCK_INVARIANT_TPL &#8212; Macro used to specify block invariants within a type-dependent scope (e.g., within templates). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.block_invariant_hpp" title="Header &lt;contract/block_invariant.hpp&gt;">contract/block_invariant.hpp</a>&gt;
</span>CONTRACT_BLOCK_INVARIANT_TPL(assertions)</pre></div><div class="refsect1" title="Description"><a name="id717507"></a><h2>Description</h2><p>This macro is the exact same as <code class="computeroutput"><a class="link" href="#CONTRACT_BLOCK_INVARIANT" title="Macro CONTRACT_BLOCK_INVARIANT">CONTRACT_BLOCK_INVARIANT</a></code> but is must be used when specifying block invariants within a type-dependent scope.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/body.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.body_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/body.hpp" target="_top">contract/body.hpp</a>&gt;</h3></div></div></div><p>Macros used to program body definitions separately from the contract declarations (this header is automatically include by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a>(function_name)
<a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a>(class_type, function_name)
<a class="link" href="#CONTRACT_CONSTRUCTOR_BODY" title="Macro CONTRACT_CONSTRUCTOR_BODY">CONTRACT_CONSTRUCTOR_BODY</a>(class_type, constructor_name)
<a class="link" href="#CONTRACT_DESTRUCTOR_BODY" title="Macro CONTRACT_DESTRUCTOR_BODY">CONTRACT_DESTRUCTOR_BODY</a>(class_type, destructor_name)</pre><div class="refentry" title="Macro CONTRACT_FREE_BODY"><a name="CONTRACT_FREE_BODY"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_FREE_BODY</span></h2><p>CONTRACT_FREE_BODY &#8212; Macro used to name the body of free functions and free function operators. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.body_hpp" title="Header &lt;contract/body.hpp&gt;">contract/body.hpp</a>&gt;
</span>CONTRACT_FREE_BODY(function_name)</pre></div><div class="refsect1" title="Description"><a name="id719237"></a><h2>Description</h2><p>This macro is used to name the body of free functions and free function operators when the body is defined separately from the contract declaration. Free functions and free function operators with contracts are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macro.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">function_name</code></strong></span></td><td>The syntax for free function and free function operator names is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. </td></tr></tbody></table></div><p>
</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_MEMBER_BODY"><div class="refentry.separator"><hr></div><a name="CONTRACT_MEMBER_BODY"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_MEMBER_BODY</span></h2><p>CONTRACT_MEMBER_BODY &#8212; Macro used to name the body of member functions and member function operators. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.body_hpp" title="Header &lt;contract/body.hpp&gt;">contract/body.hpp</a>&gt;
</span>CONTRACT_MEMBER_BODY(class_type, function_name)</pre></div><div class="refsect1" title="Description"><a name="id719318"></a><h2>Description</h2><p>This macro is used to name the body of member functions and member function operators when the body is defined separately from the contract declaration. Member functions and member function operators with contracts are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macro.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">class_type</code></strong></span></td><td>The syntax for the class type is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section (for class templates, this type is qualified with the template parameters). </td></tr><tr><td><span class="bold"><strong><code class="computeroutput">function_name</code></strong></span></td><td>The syntax for function and operator names is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. </td></tr></tbody></table></div><p>
</p><p><span class="bold"><strong>Warning:</strong></span> This macro must also be used when a virtual function invokes the overridden function from one of its base classes (see the <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONSTRUCTOR_BODY"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONSTRUCTOR_BODY"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONSTRUCTOR_BODY</span></h2><p>CONTRACT_CONSTRUCTOR_BODY &#8212; Macro used to name the body of constructors. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.body_hpp" title="Header &lt;contract/body.hpp&gt;">contract/body.hpp</a>&gt;
</span>CONTRACT_CONSTRUCTOR_BODY(class_type, constructor_name)</pre></div><div class="refsect1" title="Description"><a name="id719429"></a><h2>Description</h2><p>This macro is used to name the body of constructors when the body is defined separately from the contract declaration. Constructors with contracts are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code> macro.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">class_type</code></strong></span></td><td>The syntax for the class type is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section (for class templates, this type is qualified with the template parameters). </td></tr><tr><td><span class="bold"><strong><code class="computeroutput">constructor_name</code></strong></span></td><td>This is the class name and its syntax is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section (for class templates, this name is <span class="emphasis"><em>not</em></span> qualified with the template parameters). </td></tr></tbody></table></div><p>
</p><p><span class="bold"><strong>Warning:</strong></span> The body of constructors with member initializers should always be defined together with the constructor declaration and its contract.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_DESTRUCTOR_BODY"><div class="refentry.separator"><hr></div><a name="CONTRACT_DESTRUCTOR_BODY"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_DESTRUCTOR_BODY</span></h2><p>CONTRACT_DESTRUCTOR_BODY &#8212; Macro used to name the body of destructors. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.body_hpp" title="Header &lt;contract/body.hpp&gt;">contract/body.hpp</a>&gt;
</span>CONTRACT_DESTRUCTOR_BODY(class_type, destructor_name)</pre></div><div class="refsect1" title="Description"><a name="id719539"></a><h2>Description</h2><p>This macro is used to name the body of destructors when the body is defined separately from the contract declaration. Destructors with contracts are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code> macro.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">class_type</code></strong></span></td><td>The syntax for the class type is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section (for class templates, this type is qualified with the template parameters). </td></tr><tr><td><span class="bold"><strong><code class="computeroutput">destructor_name</code></strong></span></td><td>This is the class name prefixed by the tilde symbol <code class="computeroutput">~</code> and its syntax is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section (for class templates, this name is <span class="emphasis"><em>not</em></span> qualified with the template parameters). </td></tr></tbody></table></div><p>
</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/broken.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.broken_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/broken.hpp" target="_top">contract/broken.hpp</a>&gt;</h3></div></div></div><p>Contract broken handlers (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">contract</span> <span class="special">{</span>
<span class="keyword">class</span> <a class="link" href="#contract.broken" title="Class broken">broken</a><span class="special">;</span>
<span class="keyword">enum</span> <a class="link" href="#contract.from" title="Type from">from</a><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">handler_function_pointer</span> <a class="link" href="#contract.broken_contract_handler" title="Type definition broken_contract_handler"><span class="identifier">broken_contract_handler</span></a><span class="special">;</span>
<span class="comment">// Set precondition broken handler to specified handler returning replaced handler. </span>
<span class="identifier">broken_contract_handler</span>
<a name="contract.set_precondition_broken"></a><span class="identifier">set_precondition_broken</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="keyword">void</span> <a class="link" href="#contract.precondition_broken" title="Function precondition_broken"><span class="identifier">precondition_broken</span></a><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// Set postcondition broken handler to specified handler returning replaced handler. </span>
<span class="identifier">broken_contract_handler</span>
<a name="contract.set_postcondition_broken"></a><span class="identifier">set_postcondition_broken</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="keyword">void</span> <a class="link" href="#contract.postcondition_broken" title="Function postcondition_broken"><span class="identifier">postcondition_broken</span></a><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// Set handler for class invariant broken on entry to specified handler returning replaced handler. </span>
<span class="identifier">broken_contract_handler</span>
<a name="contract.set_class_invaria_id485380"></a><span class="identifier">set_class_invariant_broken_on_entry</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="keyword">void</span> <a class="link" href="#contract.class_invariant_b_id485392" title="Function class_invariant_broken_on_entry"><span class="identifier">class_invariant_broken_on_entry</span></a><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// Set handler for class invariant broken on exit to specified handler returning replaced handler. </span>
<span class="identifier">broken_contract_handler</span>
<a name="contract.set_class_invaria_id485458"></a><span class="identifier">set_class_invariant_broken_on_exit</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="keyword">void</span> <a class="link" href="#contract.class_invariant_b_id485470" title="Function class_invariant_broken_on_exit"><span class="identifier">class_invariant_broken_on_exit</span></a><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// Set handler for class invariant broken on throw to specified handler returning replaced handler. </span>
<span class="identifier">broken_contract_handler</span>
<a name="contract.set_class_invaria_id485536"></a><span class="identifier">set_class_invariant_broken_on_throw</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="keyword">void</span> <a class="link" href="#contract.class_invariant_b_id485548" title="Function class_invariant_broken_on_throw"><span class="identifier">class_invariant_broken_on_throw</span></a><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// For convenience, set all class invariant broken handlers (on entry, on exit, and on throw) to specified handler. </span>
<span class="keyword">void</span> <a name="contract.set_class_invariant_broken"></a><span class="identifier">set_class_invariant_broken</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="comment">// Set block invariant broken handler to specified handler returning replaced handler. </span>
<span class="identifier">broken_contract_handler</span>
<a name="contract.set_block_invariant_broken"></a><span class="identifier">set_block_invariant_broken</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="keyword">void</span> <a class="link" href="#contract.block_invariant_broken" title="Function block_invariant_broken"><span class="identifier">block_invariant_broken</span></a><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// Set the loop variant broken handler to specified handler returning replaced handler. </span>
<span class="identifier">broken_contract_handler</span>
<a name="contract.set_loop_variant_broken"></a><span class="identifier">set_loop_variant_broken</span><span class="special">(</span><span class="identifier">broken_contract_handler</span> handler<span class="special">)</span><span class="special">;</span>
<span class="keyword">void</span> <a class="link" href="#contract.loop_variant_broken" title="Function loop_variant_broken"><span class="identifier">loop_variant_broken</span></a><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span></pre><div class="refentry" title="Class broken"><a name="contract.broken"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Class broken</span></h2><p>contract::broken &#8212; Exception automatically thrown by the library to signal a contract assertion failure. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">class</span> <a class="link" href="#contract.broken" title="Class broken">broken</a> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="comment">// <a class="link" href="#contract.brokenconstruct-copy-destruct">construct/copy/destruct</a></span>
<span class="keyword">explicit</span> <a class="link" href="#id485058-bb"><span class="identifier">broken</span></a><span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span><span class="special">,</span>
<span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span><span class="special">;</span>
<a class="link" href="#id485088-bb"><span class="identifier">broken</span></a><span class="special">(</span><a class="link" href="#contract.broken" title="Class broken">broken</a> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
broken&amp; <a class="link" href="#id485099-bb"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="#contract.broken" title="Class broken">broken</a> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<a class="link" href="#id485110-bb"><span class="special">~</span><span class="identifier">broken</span></a><span class="special">(</span><span class="keyword">void</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// <a class="link" href="#id484982-bb">public member functions</a></span>
<span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> <a class="link" href="#id484984-bb"><span class="identifier">what</span></a><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> <a class="link" href="#id484998-bb"><span class="identifier">file_name</span></a><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">const</span> <a class="link" href="#id485012-bb"><span class="identifier">line_number</span></a><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> <a class="link" href="#id485025-bb"><span class="identifier">assertion_code</span></a><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="keyword">const</span> <a class="link" href="#id485039-bb"><span class="identifier">assertion_number</span></a><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="special">}</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id720694"></a><h2>Description</h2><p>This exception contains detailed information about the failed contract assertion (file name, line number, etc).</p><p>A contract assertion is considered failed if it cannot be evaluated to be true (so if it is evaluated to be false but also if an exception is thrown by the code that evaluates the assertion condition). In case a contract assertion fails, the library automatically calls the appropriate contract broken handler with this exception as the active exception (the fact that assertion failures are signaled by this library by throwing this exception does not necessarily mean that the exception will be ultimately thrown by the broken contract, that is entirely up to the implementation of the contract broken handlers). By default, contract broken handlers print an error message to <code class="computeroutput">std::cerr</code> and terminate the program calling <code class="computeroutput">std::terminate</code>, but programmers can redefine this behaviour by customizing the contract broken handlers (for example to have the handlers throw exceptions instead of terminating the program). Within customized contract broken handlers, programmers can re-throw and catch this exception to obtained information about the failed asserted condition (file name, line number, etc).</p><p><span class="bold"><strong>Note:</strong></span> This exception is guaranteed to publicly inherit from <code class="computeroutput">std::logic_error</code> (because <code class="computeroutput">std::logic_error</code> models programming errors and those are the type of errors that contract assertions detect).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p><div class="refsect2" title="broken public construct/copy/destruct"><a name="id720738"></a><h3><a name="contract.brokenconstruct-copy-destruct"></a><code class="computeroutput">broken</code>
public
construct/copy/destruct</h3><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><pre class="literallayout"><span class="keyword">explicit</span> <a name="id485058-bb"></a><span class="identifier">broken</span><span class="special">(</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> file_name<span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">const</span> <span class="special">&amp;</span> line_number<span class="special">,</span>
<span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> assertion_code<span class="special">,</span>
<span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="keyword">const</span> <span class="special">&amp;</span> assertion_number <span class="special">=</span> <span class="number">0</span><span class="special">)</span><span class="special">;</span></pre>Construct this exception specifying the failed assertion file name, line number, assertion code, and assertion number (no-throw). <p>The assertion number is optional and it defaults to zero (an assertion number equal to zero is ignored and not shown in the error description). </p></li><li class="listitem"><pre class="literallayout"><a name="id485088-bb"></a><span class="identifier">broken</span><span class="special">(</span><a class="link" href="#contract.broken" title="Class broken">broken</a> <span class="keyword">const</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>Copy constructor (no-throw). </li><li class="listitem"><pre class="literallayout">broken&amp; <a name="id485099-bb"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="#contract.broken" title="Class broken">broken</a> <span class="keyword">const</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>Copy operator (no-throw). </li><li class="listitem"><pre class="literallayout"><a name="id485110-bb"></a><span class="special">~</span><span class="identifier">broken</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span><span class="special">;</span></pre>Virtual destructor (no-throw). </li></ol></div></div><div class="refsect2" title="broken public member functions"><a name="id720985"></a><h3><a name="id484982-bb"></a><code class="computeroutput">broken</code> public member functions</h3><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><pre class="literallayout"><span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> <a name="id484984-bb"></a><span class="identifier">what</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Return a description of the assertion failure (no-throw). </li><li class="listitem"><pre class="literallayout"><span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> <a name="id484998-bb"></a><span class="identifier">file_name</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Return the name of the file containing the failed assertion (no-throw). </li><li class="listitem"><pre class="literallayout"><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">const</span> <a name="id485012-bb"></a><span class="identifier">line_number</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Return the number of the line containing the failed assertion (no-throw). </li><li class="listitem"><pre class="literallayout"><span class="keyword">char</span> <span class="keyword">const</span> <span class="special">*</span> <a name="id485025-bb"></a><span class="identifier">assertion_code</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Return the text of the asserted code that failed (no-throw). </li><li class="listitem"><pre class="literallayout"><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="keyword">const</span> <a name="id485039-bb"></a><span class="identifier">assertion_number</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Return the number of the failed assertion (no-throw). <p>The assertion number is useful only within the context of a specific contract broken handler that can differentiates between broken preconditions, postconditions, etc because different preconditions, postconditions, etc will in general have the same assertion number (the first precondition is assertion number 1, the first postcondition is also assertion number 1, etc).</p><p>If this number is zero then no sensible assertion number was specified and it should be ignored (e.g., loop variant assertions have no assertion number because there can only be one single variant for a loop). </p></li></ol></div></div></div></div><div class="refentry" title="Type from"><div class="refentry.separator"><hr></div><a name="contract.from"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Type from</span></h2><p>contract::from &#8212; Specify the context from which the contract assertion failed. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">enum</span> <span class="identifier">from</span> <span class="special">{</span> <a class="link" href="#contract.from.FROM_CONSTRUCTOR">FROM_CONSTRUCTOR</a>, <a class="link" href="#contract.from.FROM_DESTRUCTOR">FROM_DESTRUCTOR</a>, <a class="link" href="#contract.from.FROM_NONSTATIC_MEMBER_FUNCTION">FROM_NONSTATIC_MEMBER_FUNCTION</a>,
<a class="link" href="#contract.from.FROM_STATIC_MEMBER_FUNCTION">FROM_STATIC_MEMBER_FUNCTION</a>, <a class="link" href="#contract.from.FROM_FREE_FUNCTION">FROM_FREE_FUNCTION</a>, <a class="link" href="#contract.from.FROM_BODY">FROM_BODY</a> <span class="special">}</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id721319"></a><h2>Description</h2><p>This information is important because in order to comply with STL exception safety requirements, destructors shall never throw an exception. Therefore, even if programmers customize the contract broken handlers to throw an exception instead of terminating the program, it is still important to know at least if the assertion failed from a destructor's contract so programmers can avoid throwing an exception from the broken handlers in such a case.</p><p><span class="bold"><strong>Note:</strong></span> All the different contexts identified by this enumeration have different contract checking semantics (see also <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a>) so it might be relevant to differentiate between them in the contract broken handlers.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p><div class="variablelist"><dl><dt><span class="term"><code class="computeroutput">FROM_CONSTRUCTOR</code><a name="contract.from.FROM_CONSTRUCTOR"></a></span></dt><dd>Assertion failed from within constructor contracts. </dd><dt><span class="term"><code class="computeroutput">FROM_DESTRUCTOR</code><a name="contract.from.FROM_DESTRUCTOR"></a></span></dt><dd>Assertion failed from within destructor contracts. </dd><dt><span class="term"><code class="computeroutput">FROM_NONSTATIC_MEMBER_FUNCTION</code><a name="contract.from.FROM_NONSTATIC_MEMBER_FUNCTION"></a></span></dt><dd>Assertion failed from within non-static member function contracts. </dd><dt><span class="term"><code class="computeroutput">FROM_STATIC_MEMBER_FUNCTION</code><a name="contract.from.FROM_STATIC_MEMBER_FUNCTION"></a></span></dt><dd>Assertion failed from within static member function contracts. </dd><dt><span class="term"><code class="computeroutput">FROM_FREE_FUNCTION</code><a name="contract.from.FROM_FREE_FUNCTION"></a></span></dt><dd>Assertion failed from within free function contracts. </dd><dt><span class="term"><code class="computeroutput">FROM_BODY</code><a name="contract.from.FROM_BODY"></a></span></dt><dd>Assertion failed from within body contracts (for both block invariants and loop variants). </dd></dl></div></div></div><div class="refentry" title="Type definition broken_contract_handler"><div class="refentry.separator"><hr></div><a name="contract.broken_contract_handler"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Type definition broken_contract_handler</span></h2><p>broken_contract_handler &#8212; Contract broken handler function pointer. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">typedef</span> <span class="identifier">handler_function_pointer</span> <span class="identifier">broken_contract_handler</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id721566"></a><h2>Description</h2><p>A contract broken handler is a function returning <code class="computeroutput">void</code> and taking only one parameter of type <code class="computeroutput"><a class="link" href="#contract.from" title="Type from">from</a></code> indicating the context from which the contract assertion failed:</p><pre class="programlisting"><span class="keyword">typedef</span> <span class="keyword">void</span> <span class="special">(</span><span class="special">*</span><span class="identifier">handler_function_pointer</span><span class="special">)</span> <span class="special">(</span> <span class="identifier">from</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">context</span> <span class="special">)</span> <span class="special">;</span>
</pre><p><span class="bold"><strong>Note:</strong></span> This function prototype is not non-throw to allow programmers to customize the contract broken handlers to throw exceptions if they wish to do so.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Function precondition_broken"><div class="refentry.separator"><hr></div><a name="contract.precondition_broken"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Function precondition_broken</span></h2><p>contract::precondition_broken &#8212; Broken handler called when a precondition assertion fails. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">void</span> <span class="identifier">precondition_broken</span><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span> context<span class="special">)</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id721724"></a><h2>Description</h2><p>By default, it prints information about the failed assertion to <code class="computeroutput">std::cerr</code> and it calls <code class="computeroutput">std::terminate</code>. However, it can be customized using <code class="computeroutput"><code class="computeroutput"><a class="link" href="#contract.set_precondition_broken">contract::set_precondition_broken</a></code></code> (even to throw exceptions).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">context</code></strong></span></td><td>Context from which the precondition assertion failed. </td></tr></tbody></table></div><p>
</p><p>This handler is automatically called by the library in case of a precondition assertion failure (an assertion fails if it is not evaluated to be true, so if it is evaluated to be false but also if it cannot be evaluated because an exception is thrown by the asserted condition).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Function postcondition_broken"><div class="refentry.separator"><hr></div><a name="contract.postcondition_broken"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Function postcondition_broken</span></h2><p>contract::postcondition_broken &#8212; Broken handler called when a postcondition assertion fails. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">void</span> <span class="identifier">postcondition_broken</span><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span> context<span class="special">)</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id721850"></a><h2>Description</h2><p>By default, it prints information about the failed assertion to <code class="computeroutput">std::cerr</code> and it calls <code class="computeroutput">std::terminate</code>. However, it can be customized using <code class="computeroutput"><code class="computeroutput"><a class="link" href="#contract.set_postcondition_broken">contract::set_postcondition_broken</a></code></code> (even to throw exceptions).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">context</code></strong></span></td><td>Context from which the postcondition assertion failed. </td></tr></tbody></table></div><p>
</p><p>This handler is automatically called by the library in case of a postcondition assertion failure (an assertion fails if it is not evaluated to be true, so if it is evaluated to be false but also if it cannot be evaluated because an exception is thrown by the asserted condition).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Function class_invariant_broken_on_entry"><div class="refentry.separator"><hr></div><a name="contract.class_invariant_b_id485392"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Function class_invariant_broken_on_entry</span></h2><p>contract::class_invariant_broken_on_entry &#8212; Broken handler called when a class invariant assertion fails on function entry. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">void</span> <span class="identifier">class_invariant_broken_on_entry</span><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span> context<span class="special">)</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id721976"></a><h2>Description</h2><p>By default, it prints information about the failed assertion to <code class="computeroutput">std::cerr</code> and it calls <code class="computeroutput">std::terminate</code>. However, it can be customized using <code class="computeroutput"><code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485380">contract::set_class_invariant_broken_on_entry</a></code></code> (even to throw exceptions, but programmers should be careful to never throw from destructors).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">context</code></strong></span></td><td>Context from which the class invariants assertion failed (destructors, etc). </td></tr></tbody></table></div><p>
</p><p>This handler is automatically called by the library in case of a class invariant assertion failure (an assertion fails if it is not evaluated to be true, so if it is evaluated to be false but also if it cannot be evaluated because an exception is thrown by the asserted condition).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Function class_invariant_broken_on_exit"><div class="refentry.separator"><hr></div><a name="contract.class_invariant_b_id485470"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Function class_invariant_broken_on_exit</span></h2><p>contract::class_invariant_broken_on_exit &#8212; Broken handler called when a class invariant assertion fails on function exit. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">void</span> <span class="identifier">class_invariant_broken_on_exit</span><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span> context<span class="special">)</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id722101"></a><h2>Description</h2><p>By default, it prints information about the failed assertion to <code class="computeroutput">std::cerr</code> and it calls <code class="computeroutput">std::terminate</code>. However, it can be customized using <code class="computeroutput"><code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485458">contract::set_class_invariant_broken_on_exit</a></code></code> (even to throw exceptions, but programmers should be careful to never throw from destructors).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">context</code></strong></span></td><td>Context from which the class invariants assertion failed (destructors, etc). </td></tr></tbody></table></div><p>
</p><p>This handler is automatically called by the library in case of a class invariant assertion failure (an assertion fails if it is not evaluated to be true, so if it is evaluated to be false but also if it cannot be evaluated because an exception is thrown by the asserted condition).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Function class_invariant_broken_on_throw"><div class="refentry.separator"><hr></div><a name="contract.class_invariant_b_id485548"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Function class_invariant_broken_on_throw</span></h2><p>contract::class_invariant_broken_on_throw &#8212; Broken handler called when a class invariant assertion fails on function exit after the function body threw an exception. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">void</span> <span class="identifier">class_invariant_broken_on_throw</span><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span> context<span class="special">)</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id722226"></a><h2>Description</h2><p>By default, it prints information about the failed assertion to <code class="computeroutput">std::cerr</code> and it calls <code class="computeroutput">std::terminate</code>. However, it can be customized using <code class="computeroutput"><code class="computeroutput"><a class="link" href="#contract.set_class_invaria_id485536">contract::set_class_invariant_broken_on_throw</a></code></code> (even to throw exceptions, but programmers should be careful to never throw from destructors).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">context</code></strong></span></td><td>Context from which the class invariants assertion failed (destructors, etc). </td></tr></tbody></table></div><p>
</p><p>This handler is automatically called by the library in case of a class invariant assertion failure (an assertion fails if it is not evaluated to be true, so if it is evaluated to be false but also if it cannot be evaluated because an exception is thrown by the asserted condition).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Function block_invariant_broken"><div class="refentry.separator"><hr></div><a name="contract.block_invariant_broken"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Function block_invariant_broken</span></h2><p>contract::block_invariant_broken &#8212; Broken handler called when a block invariant assertion fails. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">void</span> <span class="identifier">block_invariant_broken</span><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span> context<span class="special">)</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id722352"></a><h2>Description</h2><p>By default, it prints information about the failed assertion to <code class="computeroutput">std::cerr</code> and it calls <code class="computeroutput">std::terminate</code>. However, it can be customized using <code class="computeroutput"><code class="computeroutput"><a class="link" href="#contract.set_block_invariant_broken">contract::set_block_invariant_broken</a></code></code> (even to throw exceptions, but programmers should be careful to never throw from destructors).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">context</code></strong></span></td><td>Context from which the block invariants assertion failed (i.e., the body). </td></tr></tbody></table></div><p>
</p><p>This handler is automatically called by the library in case of a block invariant assertion failure (an assertion fails if it is not evaluated to be true, so if it is evaluated to be false but also if it cannot be evaluated because an exception is thrown by the asserted condition).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Function loop_variant_broken"><div class="refentry.separator"><hr></div><a name="contract.loop_variant_broken"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Function loop_variant_broken</span></h2><p>contract::loop_variant_broken &#8212; Broken handler called when a loop variant assertion fails. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.broken_hpp" title="Header &lt;contract/broken.hpp&gt;">contract/broken.hpp</a>&gt;
</span>
<span class="keyword">void</span> <span class="identifier">loop_variant_broken</span><span class="special">(</span><span class="identifier">from</span> <span class="keyword">const</span> <span class="special">&amp;</span> context<span class="special">)</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id722478"></a><h2>Description</h2><p>By default, it prints information about the failed assertion to <code class="computeroutput">std::cerr</code> and it calls <code class="computeroutput">std::terminate</code>. However, it can be customized using <code class="computeroutput"><code class="computeroutput"><a class="link" href="#contract.set_loop_variant_broken">contract::set_loop_variant_broken</a></code></code> (even to throw exceptions, but programmers should be careful to never throw from destructors).</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">context</code></strong></span></td><td>Context from which the loop variants assertion failed (i.e., the body). </td></tr></tbody></table></div><p>
</p><p>This handler is automatically called by the library in case of a loop invariant assertion failure (an assertion fails if it is not evaluated to be true, so if it is evaluated to be false but also if it cannot be evaluated because an exception is thrown by the asserted condition).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/class.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.class_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/class.hpp" target="_top">contract/class.hpp</a>&gt;</h3></div></div></div><p>Macros used to declare classes with contracts (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a>(class_declaration)
<a class="link" href="#CONTRACT_CLASS_TPL" title="Macro CONTRACT_CLASS_TPL">CONTRACT_CLASS_TPL</a>(class_declaration)</pre><div class="refentry" title="Macro CONTRACT_CLASS"><a name="CONTRACT_CLASS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CLASS</span></h2><p>CONTRACT_CLASS &#8212; Macro used to declare classes with contracts. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.class_hpp" title="Header &lt;contract/class.hpp&gt;">contract/class.hpp</a>&gt;
</span>CONTRACT_CLASS(class_declaration)</pre></div><div class="refsect1" title="Description"><a name="id722599"></a><h2>Description</h2><p>This macro is used to declare a class with class invariants and member functions with preconditions and postconditions. A class declared with this macro must always specify (possibly empty) class invariants using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code> macro.</p><p>Constructors, destructors, and member functions with contracts are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code>, <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code>, and <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macros respectively. The semantics of calls to constructors, destructors, and member functions with contracts are explained in the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">class_declaration</code></strong></span></td><td>The class declaration syntax is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. If present, base classes must be specified using <code class="computeroutput">extends( ... )</code>. </td></tr></tbody></table></div><p>
</p><p>Nested classes with contracts are also declared using this macro but they must always repeat their access level <code class="computeroutput">public</code>, <code class="computeroutput">protected</code>, or <code class="computeroutput">private</code>. Within a type-dependent scope, nested classes with contracts must be declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_TPL" title="Macro CONTRACT_CLASS_TPL">CONTRACT_CLASS_TPL</a></code> macro.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CLASS_TPL"><div class="refentry.separator"><hr></div><a name="CONTRACT_CLASS_TPL"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CLASS_TPL</span></h2><p>CONTRACT_CLASS_TPL &#8212; Macro used to declare nested classes with contracts within a type-dependent scope (e.g., within templates). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.class_hpp" title="Header &lt;contract/class.hpp&gt;">contract/class.hpp</a>&gt;
</span>CONTRACT_CLASS_TPL(class_declaration)</pre></div><div class="refsect1" title="Description"><a name="id722740"></a><h2>Description</h2><p>This macro is the exact same as <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> but it must be used when declaring nested classes with contracts within a type-dependent scope.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/class_invariant.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.class_invariant_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/class_invariant.hpp" target="_top">contract/class_invariant.hpp</a>&gt;</h3></div></div></div><p>Macros used to specify class invariants (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a>(class_invariants)
<a class="link" href="#CONTRACT_CLASS_INVARIANT_TPL" title="Macro CONTRACT_CLASS_INVARIANT_TPL">CONTRACT_CLASS_INVARIANT_TPL</a>(class_invariants)</pre><div class="refentry" title="Macro CONTRACT_CLASS_INVARIANT"><a name="CONTRACT_CLASS_INVARIANT"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CLASS_INVARIANT</span></h2><p>CONTRACT_CLASS_INVARIANT &#8212; Macro used to specify class invariants. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.class_invariant_hpp" title="Header &lt;contract/class_invariant.hpp&gt;">contract/class_invariant.hpp</a>&gt;
</span>CONTRACT_CLASS_INVARIANT(class_invariants)</pre></div><div class="refsect1" title="Description"><a name="id722821"></a><h2>Description</h2><p>This macro must be used to specify class invariant at the very beginning of the definition of a class with contracts declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> macro (no other statement can appear before this macro in the class definition, not even a <code class="computeroutput">typedef</code> or a <code class="computeroutput">friend</code> declaration).</p><p>Constructors, destructors, and member functions with contracts are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code>, <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code>, and <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macros respectively. The semantics of calls to constructors, destructors, and member functions of a class with contracts are explained in the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">class_invariants</code></strong></span></td><td>The syntax for class invariants is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. Use <code class="computeroutput">void</code> to specify empty class invariant. </td></tr></tbody></table></div><p>
</p><p>Within a type-dependent scope (e.g., within templates), the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT_TPL" title="Macro CONTRACT_CLASS_INVARIANT_TPL">CONTRACT_CLASS_INVARIANT_TPL</a></code> macro must be used instead of this macro.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CLASS_INVARIANT_TPL"><div class="refentry.separator"><hr></div><a name="CONTRACT_CLASS_INVARIANT_TPL"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CLASS_INVARIANT_TPL</span></h2><p>CONTRACT_CLASS_INVARIANT_TPL &#8212; Macro used to specify class invariants within a type-dependent scope (e.g., within templates). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.class_invariant_hpp" title="Header &lt;contract/class_invariant.hpp&gt;">contract/class_invariant.hpp</a>&gt;
</span>CONTRACT_CLASS_INVARIANT_TPL(class_invariants)</pre></div><div class="refsect1" title="Description"><a name="id722957"></a><h2>Description</h2><p>This macro is the exact same as <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS_INVARIANT" title="Macro CONTRACT_CLASS_INVARIANT">CONTRACT_CLASS_INVARIANT</a></code> but it must be used when specifying class invariants within a type-dependent scope.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/config.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.config_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/config.hpp" target="_top">contract/config.hpp</a>&gt;</h3></div></div></div><p>Macros used to configure the library behaviour at compile-time (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><p>These configuration macros have appropriate default values if left undefined. Programmers can define these macros before including any of the library headers (using compiler options like <code class="computeroutput">-D</code> for GCC, <code class="computeroutput">/D</code> for MSVC, etc) in order to change the library behaviour.</p><p>The macros <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>, <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a></code>, etc can be defined to selectively disable compilation and run-time checking of all preconditions, postconditions, etc. This is a common practice in Contract Programming to generate debug and release builds with less correctness checks but faster run-times. Note that all contracts are compiled and checked at run-time by default unless specified otherwise using these configuration macros.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.getting_started" title="Getting Started"> Getting Started</a> section, <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section. </p><pre class="synopsis">
<a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a>
<a class="link" href="#CONTRACT_CONFIG_NO_POSTCONDITIONS" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS">CONTRACT_CONFIG_NO_POSTCONDITIONS</a>
<a class="link" href="#CONTRACT_CONFIG_NO_CLASS_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS">CONTRACT_CONFIG_NO_CLASS_INVARIANTS</a>
<a class="link" href="#CONTRACT_CONFIG_NO_BLOCK_INVARIANTS" title="Macro CONTRACT_CONFIG_NO_BLOCK_INVARIANTS">CONTRACT_CONFIG_NO_BLOCK_INVARIANTS</a>
<a class="link" href="#CONTRACT_CONFIG_NO_LOOP_VARIANTS" title="Macro CONTRACT_CONFIG_NO_LOOP_VARIANTS">CONTRACT_CONFIG_NO_LOOP_VARIANTS</a>
<a class="link" href="#CONTRACT_CONFIG_FUNCTION_ARITY_MAX" title="Macro CONTRACT_CONFIG_FUNCTION_ARITY_MAX">CONTRACT_CONFIG_FUNCTION_ARITY_MAX</a>
<a class="link" href="#CONTRACT_CONFIG_INHERITANCE_MAX" title="Macro CONTRACT_CONFIG_INHERITANCE_MAX">CONTRACT_CONFIG_INHERITANCE_MAX</a>
<a class="link" href="#CONTRACT_CONFIG_OLDOF_MAX" title="Macro CONTRACT_CONFIG_OLDOF_MAX">CONTRACT_CONFIG_OLDOF_MAX</a>
<a class="link" href="#CONTRACT_CONFIG_ARRAY_DIMENSION_MAX" title="Macro CONTRACT_CONFIG_ARRAY_DIMENSION_MAX">CONTRACT_CONFIG_ARRAY_DIMENSION_MAX</a>
<a class="link" href="#CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS" title="Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS">CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</a>
<a class="link" href="#CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION" title="Macro CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION">CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION</a>
<a class="link" href="#CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE" title="Macro CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE">CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE</a>
<a class="link" href="#CONTRACT_CONFIG_THREAD_SAFE" title="Macro CONTRACT_CONFIG_THREAD_SAFE">CONTRACT_CONFIG_THREAD_SAFE</a></pre><div class="refentry" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS"><a name="CONTRACT_CONFIG_NO_PRECONDITIONS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_NO_PRECONDITIONS</span></h2><p>CONTRACT_CONFIG_NO_PRECONDITIONS &#8212; Disable compilation and run-time checking of all preconditions. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_NO_PRECONDITIONS</pre></div><div class="refsect1" title="Description"><a name="id723136"></a><h2>Description</h2><p>Preconditions are not checked at run-time and not even compiled when programmers define this macro. This can be used to speed up execution and compilation of debug and release builds at different stages of development and testing as it is common practise in Contract Programming.</p><p><span class="bold"><strong>Note:</strong></span> Assertion requirements can be used to selectively disable single assertions (see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.getting_started" title="Getting Started"> Getting Started</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_NO_POSTCONDITIONS"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_NO_POSTCONDITIONS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_NO_POSTCONDITIONS</span></h2><p>CONTRACT_CONFIG_NO_POSTCONDITIONS &#8212; Disable compilation and run-time checking of all postconditions. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_NO_POSTCONDITIONS</pre></div><div class="refsect1" title="Description"><a name="id723191"></a><h2>Description</h2><p>Postconditions are not checked at run-time and not even compiled when programmers define this macro. This can be used to speed up execution and compilation of debug and release builds at different stages of development and testing as it is common practise in Contract Programming.</p><p><span class="bold"><strong>Note:</strong></span> Assertion requirements can be used to selectively disable single assertions (see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.getting_started" title="Getting Started"> Getting Started</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_NO_CLASS_INVARIANTS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_NO_CLASS_INVARIANTS</span></h2><p>CONTRACT_CONFIG_NO_CLASS_INVARIANTS &#8212; Disable compilation and run-time checking of all class invariants. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_NO_CLASS_INVARIANTS</pre></div><div class="refsect1" title="Description"><a name="id723246"></a><h2>Description</h2><p>Class invariants are not checked at run-time and not even compiled when programmers define this macro. This can be used to speed up execution and compilation of debug and release builds at different stages of development and testing as it is common practise in Contract Programming.</p><p><span class="bold"><strong>Note:</strong></span> Assertion requirements can be used to selectively disable single assertions (see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.getting_started" title="Getting Started"> Getting Started</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_NO_BLOCK_INVARIANTS"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_NO_BLOCK_INVARIANTS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_NO_BLOCK_INVARIANTS</span></h2><p>CONTRACT_CONFIG_NO_BLOCK_INVARIANTS &#8212; Disable compilation and run-time checking of all block invariants. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_NO_BLOCK_INVARIANTS</pre></div><div class="refsect1" title="Description"><a name="id723301"></a><h2>Description</h2><p>Block invariants are not checked at run-time and not even compiled when programmers define this macro. This can be used to speed up execution and compilation of debug and release builds at different stages of development and testing as it is common practise in Contract Programming.</p><p><span class="bold"><strong>Note:</strong></span> Assertion requirements can be used to selectively disable single assertions (see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.getting_started" title="Getting Started"> Getting Started</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_NO_LOOP_VARIANTS"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_NO_LOOP_VARIANTS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_NO_LOOP_VARIANTS</span></h2><p>CONTRACT_CONFIG_NO_LOOP_VARIANTS &#8212; Disable compilation and run-time checking of all loop variants. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_NO_LOOP_VARIANTS</pre></div><div class="refsect1" title="Description"><a name="id723356"></a><h2>Description</h2><p>Loop variants are not checked at run-time and not even compiled when programmers define this macro. This can be used to speed up execution and compilation of debug and release builds at different stages of development and testing as it is common practise in Contract Programming.</p><p><span class="bold"><strong>Note:</strong></span> Assertion requirements can be used to selectively disable single assertions (see the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.getting_started" title="Getting Started"> Getting Started</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_FUNCTION_ARITY_MAX"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_FUNCTION_ARITY_MAX"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_FUNCTION_ARITY_MAX</span></h2><p>CONTRACT_CONFIG_FUNCTION_ARITY_MAX &#8212; Specify the maximum number of supported function parameters. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_FUNCTION_ARITY_MAX</pre></div><div class="refsect1" title="Description"><a name="id723413"></a><h2>Description</h2><p>This macro automatically defaults to <code class="computeroutput">5</code> if left undefined by programmers. This macro must be a non-negative integral number. Increasing the value specified by this macro might increase compilation time.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_INHERITANCE_MAX"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_INHERITANCE_MAX"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_INHERITANCE_MAX</span></h2><p>CONTRACT_CONFIG_INHERITANCE_MAX &#8212; Specify the maximum number of base classes supported for multiple-inheritance. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_INHERITANCE_MAX</pre></div><div class="refsect1" title="Description"><a name="id723462"></a><h2>Description</h2><p>This macro automatically defaults to <code class="computeroutput">4</code> if left undefined by programmers. This macro must be a non-negative integral number. Increasing the value specified by this macro might increase compilation time.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_OLDOF_MAX"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_OLDOF_MAX"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_OLDOF_MAX</span></h2><p>CONTRACT_CONFIG_OLDOF_MAX &#8212; Specify the maximum number of supported old value declarations in postconditions. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_OLDOF_MAX</pre></div><div class="refsect1" title="Description"><a name="id723511"></a><h2>Description</h2><p>This macro automatically defaults to <code class="computeroutput">5</code> if left undefined by programmers. This macro must be a non-negative integral number smaller or equal to <code class="computeroutput"><a class="link" href="#CONTRACT_LIMIT_OLDOFS" title="Macro CONTRACT_LIMIT_OLDOFS">CONTRACT_LIMIT_OLDOFS</a></code>. Increasing the value specified by this macro might increase compilation time.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_ARRAY_DIMENSION_MAX"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_ARRAY_DIMENSION_MAX"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_ARRAY_DIMENSION_MAX</span></h2><p>CONTRACT_CONFIG_ARRAY_DIMENSION_MAX &#8212; Specify the maximum supported array dimension for multi-dimensional arrays. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_ARRAY_DIMENSION_MAX</pre></div><div class="refsect1" title="Description"><a name="id723568"></a><h2>Description</h2><p>This macro automatically defaults to <code class="computeroutput">3</code> if left undefined by programmers (therefore, by default up to 3-dimensional arrays <code class="computeroutput">x[]</code>, <code class="computeroutput">x[][]</code>, and <code class="computeroutput">x[][][]</code> can be passed to functions declared using this library, but always using an extra <code class="computeroutput">typedef</code> as specified by the <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section). This macro must be a non-negative integral number. Increasing the value specified by this macro might increase compilation time.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</span></h2><p>CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS &#8212; Do not allow overriding functions to specify preconditions. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_DO_NOT_SUBCONTRACT_PRECONDITIONS</pre></div><div class="refsect1" title="Description"><a name="id723642"></a><h2>Description</h2><p>If programmers define this macro, the library will generate a compile-time error if overriding functions specify preconditions. Therefore, preconditions can only be specified by functions at the very root of the inheritance tree and they cannot be subcontracted (this is as specified by <a class="link" href="#contract__.bibliography" title="Bibliography"> [N1962]</a>, however note that in case of multiple-inheritance the preconditions of all base functions will still be checked in logic-or with each other effectively still allowing a base class to weaken the preconditions from another base class).</p><p>By default, this library allows to subcontract preconditions.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION</span></h2><p>CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION &#8212; Specify that no assertion should be disabled while checking preconditions. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_PRECONDITIONS_DISABLE_NO_ASSERTION</pre></div><div class="refsect1" title="Description"><a name="id725044"></a><h2>Description</h2><p>Assertion checking is disabled within assertions in order to avoid infinite recursion and that is a standard requirement of Contract Programming. However, if programmers define this macro then no assertion checking is disabled within preconditions (this is as specified by <a class="link" href="#contract__.bibliography" title="Bibliography"> [N1962]</a>). Assertion checking within assertion checking will still be disabled for postconditions, class invariants, etc.</p><p>By default, this library disables assertion checking within assertions for all contracts, including preconditions.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE</span></h2><p>CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE &#8212; Report precondition that failed in the overridden function (instead of the precondition failed in the overriding function). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_REPORT_BASE_PRECONDITION_FAILURE</pre></div><div class="refsect1" title="Description"><a name="id725096"></a><h2>Description</h2><p>Subcontracted preconditions fail only when the preconditions of the overriding function fail together with the overridden preconditions from all the base classes. By default the assertion that failed in the overriding function is reported. If programmes define this macro then the library will instead the report the assertion that failed in the overridden function from within one of the base classes.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONFIG_THREAD_SAFE"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONFIG_THREAD_SAFE"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONFIG_THREAD_SAFE</span></h2><p>CONTRACT_CONFIG_THREAD_SAFE &#8212; Make the implementation of this library thread-safe. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.config_hpp" title="Header &lt;contract/config.hpp&gt;">contract/config.hpp</a>&gt;
</span>CONTRACT_CONFIG_THREAD_SAFE</pre></div><div class="refsect1" title="Description"><a name="id725140"></a><h2>Description</h2><p>In order to globally disable assertion checking within assertions, this library internally has to use a global variable. If programmers defined this macro, such a variable will be automatically locked to avoid race conditions (this effectively introduces a global lock in the program).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/constructor.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.constructor_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/constructor.hpp" target="_top">contract/constructor.hpp</a>&gt;</h3></div></div></div><p>Macros used to declare constructors with contracts (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a>(function_declaration)
<a class="link" href="#CONTRACT_CONSTRUCTOR_TPL" title="Macro CONTRACT_CONSTRUCTOR_TPL">CONTRACT_CONSTRUCTOR_TPL</a>(function_declaration)</pre><div class="refentry" title="Macro CONTRACT_CONSTRUCTOR"><a name="CONTRACT_CONSTRUCTOR"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONSTRUCTOR</span></h2><p>CONTRACT_CONSTRUCTOR &#8212; Macro used to declare constructors with contracts. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.constructor_hpp" title="Header &lt;contract/constructor.hpp&gt;">contract/constructor.hpp</a>&gt;
</span>CONTRACT_CONSTRUCTOR(function_declaration)</pre></div><div class="refsect1" title="Description"><a name="id725215"></a><h2>Description</h2><p>This macro is used to declare a constructor with possible preconditions and postconditions. At least all public constructors of a class with non-empty class invariants should be declared using this macro so to check the class invariants (even if the constructors have no precondition and no postcondition).</p><p>The semantics of a call to a constructor with contracts are explained in the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section. Destructors and member functions are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code> and <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macros respectively.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">function_declaration</code></strong></span></td><td>The constructor declaration syntax is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. Constructors must always repeat their access level <code class="computeroutput">public</code>, <code class="computeroutput">protected</code>, or <code class="computeroutput">private</code>. If present, member initializers must be specified using <code class="computeroutput">initialize( ... )</code> and within this macro (even if they are technically part of the constructor definition and not of its declaration). </td></tr></tbody></table></div><p>
</p><p>The <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> macro must be used to declare the class enclosing a constructor declared using this macro.</p><p>Within a type-dependent scope (e.g., within templates), the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_TPL" title="Macro CONTRACT_CONSTRUCTOR_TPL">CONTRACT_CONSTRUCTOR_TPL</a></code> macro must be used instead of this macro.</p><p>The <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR_BODY" title="Macro CONTRACT_CONSTRUCTOR_BODY">CONTRACT_CONSTRUCTOR_BODY</a></code> macro must be used when separating the constructor body definition form the constructor declaration programmed using this macro. Unfortunately, it is not possible to use this macro so separate body definitions for constructors that have member initializers.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_CONSTRUCTOR_TPL"><div class="refentry.separator"><hr></div><a name="CONTRACT_CONSTRUCTOR_TPL"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONSTRUCTOR_TPL</span></h2><p>CONTRACT_CONSTRUCTOR_TPL &#8212; Macro used to declare constructors with contracts within a type-dependent scope (e.g., within templates). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.constructor_hpp" title="Header &lt;contract/constructor.hpp&gt;">contract/constructor.hpp</a>&gt;
</span>CONTRACT_CONSTRUCTOR_TPL(function_declaration)</pre></div><div class="refsect1" title="Description"><a name="id725364"></a><h2>Description</h2><p>This macro is the exact same as <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code> but it must be used when declaring constructors with contracts within a type-dependent scope.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/copy.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.copy_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/copy.hpp" target="_top">contract/copy.hpp</a>&gt;</h3></div></div></div><p>Copy result value and old values for postconditions (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">contract</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">class</span> <a class="link" href="#contract.copy" title="Class template copy">copy</a><span class="special">;</span>
<span class="special">}</span></pre><div class="refentry" title="Class template copy"><a name="contract.copy"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Class template copy</span></h2><p>contract::copy &#8212; Copy result value and old values for postconditions. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.copy_hpp" title="Header &lt;contract/copy.hpp&gt;">contract/copy.hpp</a>&gt;
</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span>
<span class="keyword">class</span> <a class="link" href="#contract.copy" title="Class template copy">copy</a> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="comment">// types</span>
<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">add_reference</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">add_const</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <a name="contract.copy.const_reference_type"></a><span class="identifier">const_reference_type</span><span class="special">;</span>
<span class="comment">// <a class="link" href="#contract.copyconstruct-copy-destruct">construct/copy/destruct</a></span>
<span class="keyword">explicit</span> <a class="link" href="#id486755-bb"><span class="identifier">copy</span></a><span class="special">(</span><span class="identifier">const_reference_type</span><span class="special">)</span><span class="special">;</span>
<span class="comment">// <a class="link" href="#id486740-bb">public member functions</a></span>
<span class="identifier">const_reference_type</span> <a class="link" href="#id486742-bb"><span class="identifier">value</span></a><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="special">}</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id725688"></a><h2>Description</h2><p>The default implementation of his class template can copy values of any type that is <code class="computeroutput">ConstantCopyConstructible</code> which is of any type <code class="computeroutput">T</code> that has a constant-correct copy constructor of the form:</p><pre class="programlisting"> <span class="identifier">T</span><span class="special">::</span><span class="identifier">T</span><span class="special">(</span> <span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">source</span> <span class="special">)</span> <span class="special">;</span>
</pre><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">T</code></strong></span></td><td>The type of the value to copy (it is either the result type of the type of an old-of expression). </td></tr></tbody></table></div><p>
</p><p>Programmers can specialize this class template to copy a specific type differently (and even for types that are not <code class="computeroutput">ConstantCopyConstructible</code>, or not <code class="computeroutput">CopyConstructible</code> at all).</p><p><span class="bold"><strong>Warning:</strong></span> When specializing this class template, programmers must make sure that their code is constant-correct otherwise the contracts will no longer be constant-correct.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p><div class="refsect2" title="copy public construct/copy/destruct"><a name="id725806"></a><h3><a name="contract.copyconstruct-copy-destruct"></a><code class="computeroutput">copy</code>
public
construct/copy/destruct</h3><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><pre class="literallayout"><span class="keyword">explicit</span> <a name="id486755-bb"></a><span class="identifier">copy</span><span class="special">(</span><span class="identifier">const_reference_type</span> value<span class="special">)</span><span class="special">;</span></pre>Construct this object copying the specified value assuming <code class="computeroutput">T</code> has a constant-correct copy constructor. </li></ol></div></div><div class="refsect2" title="copy public member functions"><a name="id725859"></a><h3><a name="id486740-bb"></a><code class="computeroutput">copy</code> public member functions</h3><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><pre class="literallayout"><span class="identifier">const_reference_type</span> <a name="id486742-bb"></a><span class="identifier">value</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>Return a constant reference to the copied value. </li></ol></div></div></div></div></div><div class="section" title="Header &lt;contract/destructor.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.destructor_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/destructor.hpp" target="_top">contract/destructor.hpp</a>&gt;</h3></div></div></div><p>Macros used to declare destructors with contracts (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a>(function_declaration)
<a class="link" href="#CONTRACT_DESTRUCTOR_TPL" title="Macro CONTRACT_DESTRUCTOR_TPL">CONTRACT_DESTRUCTOR_TPL</a>(function_declaration)</pre><div class="refentry" title="Macro CONTRACT_DESTRUCTOR"><a name="CONTRACT_DESTRUCTOR"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_DESTRUCTOR</span></h2><p>CONTRACT_DESTRUCTOR &#8212; Macro used to declare destructors with contracts. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.destructor_hpp" title="Header &lt;contract/destructor.hpp&gt;">contract/destructor.hpp</a>&gt;
</span>CONTRACT_DESTRUCTOR(function_declaration)</pre></div><div class="refsect1" title="Description"><a name="id725967"></a><h2>Description</h2><p>This macro is used to declare a destructor. At least the public destructor of a class with non-empty class invariants should be declared using this macro in order to check the class invariants (even if destructors never have preconditions or postconditions).</p><p>The semantics of a call to a destructor with contracts are explained in the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section. Constructor and member functions are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code> and <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> macros respectively.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">function_declaration</code></strong></span></td><td>The destructor declaration syntax is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. Destructors must always repeat their access level <code class="computeroutput">public</code>, <code class="computeroutput">protected</code>, or <code class="computeroutput">private</code>. The keyword <code class="computeroutput">void</code> must be used to indicate that the destructor has an empty parameter list. </td></tr></tbody></table></div><p>
</p><p>The <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> macro must be used to declare the class enclosing a destructor declared using this macro.</p><p>Within a type-dependent scope (e.g., within templates), the <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_TPL" title="Macro CONTRACT_DESTRUCTOR_TPL">CONTRACT_DESTRUCTOR_TPL</a></code> macro must be used instead of this macro.</p><p>The <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR_BODY" title="Macro CONTRACT_DESTRUCTOR_BODY">CONTRACT_DESTRUCTOR_BODY</a></code> macro must be used when separating the destructor body definition from the destruction declaration programmed using this macro.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_DESTRUCTOR_TPL"><div class="refentry.separator"><hr></div><a name="CONTRACT_DESTRUCTOR_TPL"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_DESTRUCTOR_TPL</span></h2><p>CONTRACT_DESTRUCTOR_TPL &#8212; Macro used to declare destructors with contracts within a type-dependent scope (e.g., within templates). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.destructor_hpp" title="Header &lt;contract/destructor.hpp&gt;">contract/destructor.hpp</a>&gt;
</span>CONTRACT_DESTRUCTOR_TPL(function_declaration)</pre></div><div class="refsect1" title="Description"><a name="id726114"></a><h2>Description</h2><p>This macro is the exact same as <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code> but it must be used when declaring destructors with contracts within a type-dependent scope.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/function.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.function_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/function.hpp" target="_top">contract/function.hpp</a>&gt;</h3></div></div></div><p>Macros used to declare free functions, member functions, and operators with contracts (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a>(function_declaration)
<a class="link" href="#CONTRACT_FUNCTION_TPL" title="Macro CONTRACT_FUNCTION_TPL">CONTRACT_FUNCTION_TPL</a>(function_declaration)</pre><div class="refentry" title="Macro CONTRACT_FUNCTION"><a name="CONTRACT_FUNCTION"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_FUNCTION</span></h2><p>CONTRACT_FUNCTION &#8212; Macro used to declare free functions, free function operators, member functions, and member function operators with contracts. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.function_hpp" title="Header &lt;contract/function.hpp&gt;">contract/function.hpp</a>&gt;
</span>CONTRACT_FUNCTION(function_declaration)</pre></div><div class="refsect1" title="Description"><a name="id726195"></a><h2>Description</h2><p>This macro is used to declare a function with possible preconditions and postconditions. At least all public member functions and public member function operators of a class with non-empty class invariants should be declared using this macro in order to check the class invariants (even if the functions and operators have no precondition and no postcondition).</p><p>The semantics of a call to a function with contracts are explained in the <a class="link" href="#contract__.contract_programming_overview" title="Contract Programming Overview"> Contract Programming Overview</a> section. Constructors and destructors are declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code> and <code class="computeroutput"><a class="link" href="#CONTRACT_DESTRUCTOR" title="Macro CONTRACT_DESTRUCTOR">CONTRACT_DESTRUCTOR</a></code> macros respectively.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">function_declaration</code></strong></span></td><td>The function declaration syntax is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. Member functions must always repeat their access level <code class="computeroutput">public</code>, <code class="computeroutput">protected</code>, or <code class="computeroutput">private</code>. Operators use a special syntax to specify their symbols and names. </td></tr></tbody></table></div><p>
</p><p>The <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> macro must be used to declare classes enclosing member functions and member function operators declared using this macro.</p><p>Within a type-dependent scope (e.g., within templates), the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION_TPL" title="Macro CONTRACT_FUNCTION_TPL">CONTRACT_FUNCTION_TPL</a></code> macro must be used instead of this macro.</p><p>The <code class="computeroutput"><a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a></code> and <code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code> macros must be used when separating free and member function body definitions from the function declarations programmed using this macro.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_FUNCTION_TPL"><div class="refentry.separator"><hr></div><a name="CONTRACT_FUNCTION_TPL"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_FUNCTION_TPL</span></h2><p>CONTRACT_FUNCTION_TPL &#8212; Macro used to declared free functions, free function operators, member functions, and member function operators with contracts within a type-dependent scope (e.g., within templates). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.function_hpp" title="Header &lt;contract/function.hpp&gt;">contract/function.hpp</a>&gt;
</span>CONTRACT_FUNCTION_TPL(function_declaration)</pre></div><div class="refsect1" title="Description"><a name="id726344"></a><h2>Description</h2><p>This macro is the exact same as <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> but it must be used when declaring functions with contracts within a type-dependent scope.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/limits.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.limits_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/limits.hpp" target="_top">contract/limits.hpp</a>&gt;</h3></div></div></div><p>Macros reporting bounds of some library constructs (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><p>These are <span class="emphasis"><em>not</em></span> configuration macros so programmers cannot change these values. These macros are used to inform programmers of bounds on some of this library constructs. </p><pre class="synopsis">
<a class="link" href="#CONTRACT_LIMIT_OLDOFS" title="Macro CONTRACT_LIMIT_OLDOFS">CONTRACT_LIMIT_OLDOFS</a>
<a class="link" href="#CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS" title="Macro CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS">CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS</a>
<a class="link" href="#CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES" title="Macro CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES">CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES</a></pre><div class="refentry" title="Macro CONTRACT_LIMIT_OLDOFS"><a name="CONTRACT_LIMIT_OLDOFS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_LIMIT_OLDOFS</span></h2><p>CONTRACT_LIMIT_OLDOFS &#8212; Upper bound on possible maximum number of postcondition old variables. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.limits_hpp" title="Header &lt;contract/limits.hpp&gt;">contract/limits.hpp</a>&gt;
</span>CONTRACT_LIMIT_OLDOFS</pre></div><div class="refsect1" title="Description"><a name="id726435"></a><h2>Description</h2><p>The maximum possible number of postcondition old variables is <code class="computeroutput">15</code> (the actual maximum value is controlled by <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_OLDOF_MAX" title="Macro CONTRACT_CONFIG_OLDOF_MAX">CONTRACT_CONFIG_OLDOF_MAX</a></code>).</p><p>For compilers that do not support variadic macros, this is the maximum possible total number of postcondition statements (total of old variable declarations, plus return value declaration, plus assertions, etc).</p><p><span class="bold"><strong>Note:</strong></span> This is not a configuration macro. The value of this macro is fixed and programmers cannot change it.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section, <a class="link" href="#contract__.no_variadic_macros" title="No Variadic Macros"> No Variadic Macros</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS"><div class="refentry.separator"><hr></div><a name="CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS</span></h2><p>CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS &#8212; Maximum number of select assertions that can be nested into one another. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.limits_hpp" title="Header &lt;contract/limits.hpp&gt;">contract/limits.hpp</a>&gt;
</span>CONTRACT_LIMIT_NESTED_SELECT_ASSERTIONS</pre></div><div class="refsect1" title="Description"><a name="id726506"></a><h2>Description</h2><p>The maximum number of select assertions that can be nested into one another is <code class="computeroutput">5</code>.</p><p><span class="bold"><strong>Note:</strong></span> This is not a configuration macro. The value of this macro is fixed and programmers cannot change it.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES"><div class="refentry.separator"><hr></div><a name="CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES</span></h2><p>CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES &#8212; Maximum number of catch statements for a constructor-try block with member initializers. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.limits_hpp" title="Header &lt;contract/limits.hpp&gt;">contract/limits.hpp</a>&gt;
</span>CONTRACT_LIMIT_CONSTRUCTOR_TRY_BLOCK_CATCHES</pre></div><div class="refsect1" title="Description"><a name="id726561"></a><h2>Description</h2><p>The maximum number of catch statements for a constructor-try block with member initializers is <code class="computeroutput">10</code>. (Constructor-try blocks are specified outside the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code> macro when the is no member initializers so this limit does not apply to that case.)</p><p><span class="bold"><strong>Note:</strong></span> This is not a configuration macro. The value of this macro is fixed and programmers cannot change it.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/loop_variant.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.loop_variant_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/loop_variant.hpp" target="_top">contract/loop_variant.hpp</a>&gt;</h3></div></div></div><p>Macros used to specify loop variants (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_LOOP" title="Macro CONTRACT_LOOP">CONTRACT_LOOP</a>(loop_declaration)
<a class="link" href="#CONTRACT_LOOP_VARIANT" title="Macro CONTRACT_LOOP_VARIANT">CONTRACT_LOOP_VARIANT</a>(loop_variant)
<a class="link" href="#CONTRACT_LOOP_VARIANT_TPL" title="Macro CONTRACT_LOOP_VARIANT_TPL">CONTRACT_LOOP_VARIANT_TPL</a>(loop_variant)</pre><div class="refentry" title="Macro CONTRACT_LOOP"><a name="CONTRACT_LOOP"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_LOOP</span></h2><p>CONTRACT_LOOP &#8212; Macro used to declare a loop that will specify a loop variant. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.loop_variant_hpp" title="Header &lt;contract/loop_variant.hpp&gt;">contract/loop_variant.hpp</a>&gt;
</span>CONTRACT_LOOP(loop_declaration)</pre></div><div class="refsect1" title="Description"><a name="id726660"></a><h2>Description</h2><p>This macro must be used to declare a loop that will later specify a loop variant using the <code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT" title="Macro CONTRACT_LOOP_VARIANT">CONTRACT_LOOP_VARIANT</a></code> macro.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">loop_declaration</code></strong></span></td><td>This is a loop declaration (<code class="computeroutput">for</code>, <code class="computeroutput">while</code>, etc) that follows the usual C++ syntax (see also the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section). </td></tr></tbody></table></div><p>
</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_LOOP_VARIANT"><div class="refentry.separator"><hr></div><a name="CONTRACT_LOOP_VARIANT"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_LOOP_VARIANT</span></h2><p>CONTRACT_LOOP_VARIANT &#8212; Macro used to specify a loop variant. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.loop_variant_hpp" title="Header &lt;contract/loop_variant.hpp&gt;">contract/loop_variant.hpp</a>&gt;
</span>CONTRACT_LOOP_VARIANT(loop_variant)</pre></div><div class="refsect1" title="Description"><a name="id726752"></a><h2>Description</h2><p>This macro is used to specify loop variants which ensure that loops terminate. This macro must be used within the body <code class="computeroutput">{ ... }</code> of a loop declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_LOOP" title="Macro CONTRACT_LOOP">CONTRACT_LOOP</a></code> macro. Each loop can have at most one loop variant.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">loop_variant</code></strong></span></td><td>The loop variant must be a non-negative integral expression that monotonically decreases when calculated at each subsequent loop iteration (constant-expressions can also be used, see the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section). </td></tr></tbody></table></div><p>
</p><p>Within type-dependent scope (e.g., within templates), the <code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT_TPL" title="Macro CONTRACT_LOOP_VARIANT_TPL">CONTRACT_LOOP_VARIANT_TPL</a></code> macro must be used instead of this macro.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_LOOP_VARIANT_TPL"><div class="refentry.separator"><hr></div><a name="CONTRACT_LOOP_VARIANT_TPL"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_LOOP_VARIANT_TPL</span></h2><p>CONTRACT_LOOP_VARIANT_TPL &#8212; Macro used to specify a loop variant within a type-dependent scope (e.g., within templates). </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.loop_variant_hpp" title="Header &lt;contract/loop_variant.hpp&gt;">contract/loop_variant.hpp</a>&gt;
</span>CONTRACT_LOOP_VARIANT_TPL(loop_variant)</pre></div><div class="refsect1" title="Description"><a name="id726849"></a><h2>Description</h2><p>This macro is the exact same as <code class="computeroutput"><a class="link" href="#CONTRACT_LOOP_VARIANT" title="Macro CONTRACT_LOOP_VARIANT">CONTRACT_LOOP_VARIANT</a></code> but it must be used when specifying loop variants within a type-dependent scope.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/oldof.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.oldof_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/oldof.hpp" target="_top">contract/oldof.hpp</a>&gt;</h3></div></div></div><p>Constructs to declare postcondition old values (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></pre><pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">contract</span> <span class="special">{</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> OldofExpressionType<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="#contract.has_oldof" title="Struct template has_oldof">has_oldof</a><span class="special">;</span>
<span class="special">}</span></pre><div class="refentry" title="Struct template has_oldof"><a name="contract.has_oldof"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Struct template has_oldof</span></h2><p>contract::has_oldof &#8212; Trait used to determine if a type can be copied for an old value or not. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.oldof_hpp" title="Header &lt;contract/oldof.hpp&gt;">contract/oldof.hpp</a>&gt;
</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> OldofExpressionType<span class="special">&gt;</span>
<span class="keyword">struct</span> <a class="link" href="#contract.has_oldof" title="Struct template has_oldof">has_oldof</a> <span class="special">{</span>
<span class="special">}</span><span class="special">;</span></pre></div><div class="refsect1" title="Description"><a name="id727012"></a><h2>Description</h2><p>A type can be used for a postcondition old value if and only if it can be copied using the <code class="computeroutput"><a class="link" href="#contract.copy" title="Class template copy">contract::copy</a></code> template. By default, all types that have a constant-correct copy constructor (i.e., that are <code class="computeroutput">ConstantCopyConstructible</code>) can be copied by <code class="computeroutput"><a class="link" href="#contract.copy" title="Class template copy">contract::copy</a></code>.</p><p>If a type cannot be copied, an old value declaration using such a type will not fail but it will generate an old value that will cause a compile-time error as soon as it is used in a contract assertion. Therefore, this trait can be used to program assertion requirements for those assertions that use old values on generic types that are not always known to be copyable. This way, the assertions will be disabled by the requirement instead of generating a compile-time error when the old values they use cannot be copied.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">OldofExpressionType</code></strong></span></td><td>The type of the expression specified to the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code> macro for a given postcondition old value declaration. </td></tr></tbody></table></div><p>
</p><p>Unfortunately, in C++ it is not possible to portably implement a template meta-function that checks if a generic type has a constant-correct copy constructor (or even just a copy constructor). Therefore, the default implementation of this trait is <code class="computeroutput">boost::mpl::true_</code> for any type <code class="computeroutput">OdlofExpressionType</code>. This will cause compile-time errors for old value types that cannot be copied in which case users can specialize this unary boolean meta-function to inherit from <code class="computeroutput">boost::mpl::false_</code> for such types.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_OLDOF"><div class="refentry.separator"><hr></div><a name="CONTRACT_OLDOF"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_OLDOF</span></h2><p>CONTRACT_OLDOF &#8212; Macro used to refer to the old value of an expression. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.oldof_hpp" title="Header &lt;contract/oldof.hpp&gt;">contract/oldof.hpp</a>&gt;
</span>CONTRACT_OLDOF</pre></div><div class="refsect1" title="Description"><a name="id727129"></a><h2>Description</h2><p>This macro refers the old value of the expression that follows the macro (i.e., the value the expression had after function entry but before body execution). This macro must be used to initialize old value declarations within postconditions (see also the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section):</p><pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">old_variable</span> <span class="special">=</span> <span class="identifier">CONTRACT_OLDOF</span> <span class="identifier">odlof_expression</span>
</pre><p>The specified expression that follows the macro might or not be wrapped within parenthesis.</p><p>The old-of expression type can be explicitly specified instead of <code class="computeroutput">auto</code> but it must be wrapped within parenthesis unless it is a fundamental type containing no symbol. If not explicitly specified, the library will automatically deduce the type using Boost.Typeof (as always, types must be properly registered with Boost.Typeof for type-of emulation mode on compilers that do not support native type-of).</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.tutorial" title="Tutorial"> Tutorial</a> section, <a class="link" href="#contract__.advanced_topics" title="Advanced Topics"> Advanced Topics</a> section. </p></div></div></div><div class="section" title="Header &lt;contract/parameter.hpp&gt;"><div class="titlepage"><div><div><h3 class="title"><a name="header.contract.parameter_hpp"></a>Header &lt;<a class="ulink" href="../..//contract/parameter.hpp" target="_top">contract/parameter.hpp</a>&gt;</h3></div></div></div><p>Macros used to program named and deduced parameters (this header is automatically included by <code class="computeroutput">contract.hpp</code>). </p><pre class="synopsis">
<a class="link" href="#CONTRACT_CONSTRUCTOR_ARG" title="Macro CONTRACT_CONSTRUCTOR_ARG">CONTRACT_CONSTRUCTOR_ARG</a>(parameter_name)
<a class="link" href="#CONTRACT_PARAMETER_TYPEOF" title="Macro CONTRACT_PARAMETER_TYPEOF">CONTRACT_PARAMETER_TYPEOF</a>(parameter_name)
<a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a>(named_parameter_declaration)
<a class="link" href="#CONTRACT_TEMPLATE_PARAMETER" title="Macro CONTRACT_TEMPLATE_PARAMETER">CONTRACT_TEMPLATE_PARAMETER</a>(named_parameter_declaration)
<a class="link" href="#CONTRACT_PARAMETER_BODY" title="Macro CONTRACT_PARAMETER_BODY">CONTRACT_PARAMETER_BODY</a>(function_name)</pre><div class="refentry" title="Macro CONTRACT_CONSTRUCTOR_ARG"><a name="CONTRACT_CONSTRUCTOR_ARG"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_CONSTRUCTOR_ARG</span></h2><p>CONTRACT_CONSTRUCTOR_ARG &#8212; Macro used to access constructor named or deduced arguments within member initializers. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.parameter_hpp" title="Header &lt;contract/parameter.hpp&gt;">contract/parameter.hpp</a>&gt;
</span>CONTRACT_CONSTRUCTOR_ARG(parameter_name)</pre></div><div class="refsect1" title="Description"><a name="id730938"></a><h2>Description</h2><p>This macro must be used to access the constructor arguments within the member initializers. Outside of the member initializers, the parameter names are used directly as usual and without using this macro.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">parameter_name</code></strong></span></td><td>The name of a constructor named or deduced parameter previously declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code> macro. </td></tr></tbody></table></div><p>
</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.named_parameters" title="Named Parameters"> Named Parameters</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_PARAMETER_TYPEOF"><div class="refentry.separator"><hr></div><a name="CONTRACT_PARAMETER_TYPEOF"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_PARAMETER_TYPEOF</span></h2><p>CONTRACT_PARAMETER_TYPEOF &#8212; Macro used to access the actual type of a named or deduced parameter. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.parameter_hpp" title="Header &lt;contract/parameter.hpp&gt;">contract/parameter.hpp</a>&gt;
</span>CONTRACT_PARAMETER_TYPEOF(parameter_name)</pre></div><div class="refsect1" title="Description"><a name="id731015"></a><h2>Description</h2><p>Named and deduced parameters can have generic types (possibly matching predicate type requirements) so the actual parameter types are known at compile-time but only after the function call has been resolved. This macro is used to refer to the actual parameter type as it was determined by the function call resolution.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">parameter_name</code></strong></span></td><td>The name of a named or deduced parameter previously declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER" title="Macro CONTRACT_PARAMETER">CONTRACT_PARAMETER</a></code> macro. </td></tr></tbody></table></div><p>
</p><p>This macro can be used within both the function declaration and the body definition.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.named_parameters" title="Named Parameters"> Named Parameters</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_PARAMETER"><div class="refentry.separator"><hr></div><a name="CONTRACT_PARAMETER"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_PARAMETER</span></h2><p>CONTRACT_PARAMETER &#8212; Macro used to declare a named or deduced function parameter. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.parameter_hpp" title="Header &lt;contract/parameter.hpp&gt;">contract/parameter.hpp</a>&gt;
</span>CONTRACT_PARAMETER(named_parameter_declaration)</pre></div><div class="refsect1" title="Description"><a name="id731095"></a><h2>Description</h2><p>This macro is used to declare a named or deduced parameter that will later be used within a function declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code> or the <code class="computeroutput"><a class="link" href="#CONTRACT_CONSTRUCTOR" title="Macro CONTRACT_CONSTRUCTOR">CONTRACT_CONSTRUCTOR</a></code> macros. This macro should be used at namespace scope.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">named_parameter_declaration</code></strong></span></td><td>The syntax of named and deduced parameter declarations is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. At lest the parameter name must be specified. </td></tr></tbody></table></div><p>
</p><p>It is recommended to always use this macro within an enclosing namespace different from the global namespace so to control and avoid clashing declarations of named and deduced parameters that have the same name.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.named_parameters" title="Named Parameters"> Named Parameters</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_TEMPLATE_PARAMETER"><div class="refentry.separator"><hr></div><a name="CONTRACT_TEMPLATE_PARAMETER"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_TEMPLATE_PARAMETER</span></h2><p>CONTRACT_TEMPLATE_PARAMETER &#8212; Macro used to declare a named or deduced template parameter. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.parameter_hpp" title="Header &lt;contract/parameter.hpp&gt;">contract/parameter.hpp</a>&gt;
</span>CONTRACT_TEMPLATE_PARAMETER(named_parameter_declaration)</pre></div><div class="refsect1" title="Description"><a name="id731190"></a><h2>Description</h2><p>This macro is used to declare a named or deduced parameter that will later be used within a class template declared using the <code class="computeroutput"><a class="link" href="#CONTRACT_CLASS" title="Macro CONTRACT_CLASS">CONTRACT_CLASS</a></code> macro. This macro should be used at namespace scope.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">named_parameter_declaration</code></strong></span></td><td>The syntax of named and deduced parameter declarations is explained in the <a class="link" href="#contract__.grammar" title="Grammar"> Grammar</a> section. At lest the template parameter name must be specified. </td></tr></tbody></table></div><p>
</p><p>It is recommended to always use this macro within an enclosing namespace different from the global namespace so to control and avoid clashing declarations of named and deduced parameters that have the same name.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.named_parameters" title="Named Parameters"> Named Parameters</a> section. </p></div></div><div class="refentry" title="Macro CONTRACT_PARAMETER_BODY"><div class="refentry.separator"><hr></div><a name="CONTRACT_PARAMETER_BODY"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro CONTRACT_PARAMETER_BODY</span></h2><p>CONTRACT_PARAMETER_BODY &#8212; Macro used to name the body of free and member functions with named parameters. </p></div><div class="refsynopsisdiv" title="Synopsis"><h2>Synopsis</h2><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="#header.contract.parameter_hpp" title="Header &lt;contract/parameter.hpp&gt;">contract/parameter.hpp</a>&gt;
</span>CONTRACT_PARAMETER_BODY(function_name)</pre></div><div class="refsect1" title="Description"><a name="id731274"></a><h2>Description</h2><p>This macro is used to name the body of a function with named parameters when the body is defined separately from the function declaration.</p><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table border="1"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">function_name</code></strong></span></td><td>The name of the function with named parameters. </td></tr></tbody></table></div><p>
</p><p>For member functions, the class type must precede this macro (this allows to use this same macro for both free and member functions): </p><pre class="programlisting"><span class="identifier">class_type</span><span class="special">::</span><span class="identifier">CONTRACT_PARAMETER_BODY</span><span class="special">(</span><span class="identifier">function_name</span><span class="special">)</span>
</pre><p><span class="bold"><strong>Note:</strong></span> Named parameters are currently not supported for operators so this function name cannot be the name of an operator (because of a Boost.Parameter bug). Constructors with named parameters cannot defer the definition of their body (because of lack of delegating constructors in C++03). Finally, destructors have no parameter so named parameters do not apply to destructors. Therefore, this macro is never used for operators, constructors, and destructors.</p><p><span class="bold"><strong>See also:</strong></span> <a class="link" href="#contract__.named_parameters" title="Named Parameters"> Named Parameters</a> section. </p></div></div></div></div><div class="section" title="Release Notes"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.release_notes"></a><a class="link" href="#contract__.release_notes" title="Release Notes">Release Notes</a></h2></div></div></div><div class="section" title="Release 0.4.0"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.release_notes.release_0_4_0"></a><a class="link" href="#contract__.release_notes.release_0_4_0" title="Release 0.4.0">Release 0.4.0</a></h3></div></div></div><p>
June 4, 2012
</p><p>
Notes:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Simplified syntax by reducing extra parenthesis to the bare necessary
minimum (using some of the preprocessor parsing techniques originally
introduced by Boost.LocalFunction).
</li><li class="listitem">
Postcondition old values only copy the old-of expression (e.g., copy
just vector size instead of entire vector). This improves performance
and introduces the <code class="computeroutput"><span class="identifier">ConstantCopyConstructible</span></code>
requirement just for the old value expression type (e.g., a vector might
not be copyable while its size always is because it is an integral type).
Removed the <code class="computeroutput"><span class="identifier">copyable</span></code>
tag.
</li><li class="listitem">
Body defined outside the macros (so compiler-errors for definitions retain
their usual meaning).
</li><li class="listitem">
Added <code class="computeroutput"><span class="identifier">CONTRACT_CLASS</span></code>
macro and removed the need to duplicate declaration elements (do not
repeat function declaration, do not repeat class name in function declaration,
etc).
</li><li class="listitem">
Using <code class="computeroutput"><span class="identifier">_TPL</span></code> macros so
to reduce compile-time (instead of internally making all templates contract
functions so to use <code class="computeroutput"><span class="keyword">typename</span></code>
freely).
</li><li class="listitem">
Overloading no longer requires unique parameter names.
</li><li class="listitem">
Added C++11-like virtual specifiers.
</li><li class="listitem">
Added constant assertions plus constant-expressions for select assertion
if-conditions and for loop variants.
</li><li class="listitem">
Added named and deduced parameters.
</li><li class="listitem">
Added concept checking.
</li><li class="listitem">
Removed the interface to use the library without the macro (programmers
were required to write too much boiler-plate code for the non-macro interface
to be actually usable, plus supporting both the macro and non-macro interfaces
limited what the macros could do).
</li></ol></div><p>
Release <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_4_0" target="_top">files</a>
and <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_4_0/doc/html/index.html" target="_top">documentation</a>.
</p></div><div class="section" title="Release 0.3.490"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.release_notes.release_0_3_490"></a><a class="link" href="#contract__.release_notes.release_0_3_490" title="Release 0.3.490">Release 0.3.490</a></h3></div></div></div><p>
March 7, 2010
</p><p>
Notes:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Added support and examples for <code class="computeroutput"><span class="keyword">volatile</span></code>,
<code class="computeroutput"><span class="keyword">auto</span></code>, <code class="computeroutput"><span class="keyword">explicit</span></code>,
<code class="computeroutput"><span class="keyword">export</span></code>, <code class="computeroutput"><span class="keyword">extern</span></code>,
<code class="computeroutput"><span class="keyword">friend</span></code>, <code class="computeroutput"><span class="keyword">inline</span></code>,
<code class="computeroutput"><span class="keyword">struct</span></code>, and <code class="computeroutput"><span class="keyword">throw</span></code> (for exception specifications).
</li><li class="listitem">
Documented that <code class="computeroutput"><span class="keyword">union</span></code> cannot
be contracted.
</li></ol></div><p>
Release <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_3_490" target="_top">files</a>
and <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_3_490/doc/html/index.html" target="_top">documentation</a>.
</p></div><div class="section" title="Release 0.3.469"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.release_notes.release_0_3_469"></a><a class="link" href="#contract__.release_notes.release_0_3_469" title="Release 0.3.469">Release 0.3.469</a></h3></div></div></div><p>
February 21, 2010
</p><p>
Notes:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Removed use of <code class="computeroutput"><span class="identifier">self</span></code>,
<code class="computeroutput"><span class="identifier">variable</span><span class="special">.</span><span class="identifier">now</span></code>, and <code class="computeroutput"><span class="identifier">variable</span><span class="special">.</span><span class="identifier">old</span></code>
in writing contracts. Object <code class="computeroutput"><span class="keyword">this</span></code>
and variables are now accessed as usual in member functions. <code class="computeroutput"><span class="identifier">CONTRACT_OLDOF</span><span class="special">(</span><span class="identifier">variable</span><span class="special">)</span></code>
is used to access old values in postconditions.
</li><li class="listitem">
Added <code class="computeroutput"><span class="special">(</span><span class="identifier">precondition</span><span class="special">)</span></code>, <code class="computeroutput"><span class="special">(</span><span class="identifier">postcondition</span><span class="special">)</span></code>,
and <code class="computeroutput"><span class="special">(</span><span class="identifier">body</span><span class="special">)</span></code> to specify contracts within the function
signature sequence. If no preconditions then <code class="computeroutput"><span class="special">(</span><span class="identifier">precondition</span><span class="special">)</span>
<span class="special">({...})</span></code> is simply omitted from
the sequence (same for postconditions, body is mandatory instead). For
non-void functions, users can name the result argument with <code class="computeroutput"><span class="special">(</span><span class="identifier">postcondition</span><span class="special">)</span> <span class="special">(</span><span class="identifier">result</span><span class="special">-</span><span class="identifier">name</span><span class="special">)</span> <span class="special">({...})</span></code>.
</li><li class="listitem">
Changed contract class template to use same syntax as Boost.Function
(i.e., <code class="computeroutput"><span class="identifier">F</span></code> function type).
</li><li class="listitem">
Added support for free functions and static member functions.
</li><li class="listitem">
Added support for subcontracting with multiple inheritance.
</li><li class="listitem">
Added static class invariants which are always checked (also at constructors
entry, destructor exit, and by static member functions).
</li><li class="listitem">
Added block invariants and Eiffel-like loop variants.
</li><li class="listitem">
Added handlers to customize action on contract failure (default to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">terminate</span><span class="special">()</span></code>).
</li><li class="listitem">
Removed feature for automatic contract documentation using Doxygen (this
is not compatible with added <code class="computeroutput"><span class="special">(</span><span class="identifier">precondition</span><span class="special">)</span></code>,
<code class="computeroutput"><span class="special">(</span><span class="identifier">postcondition</span><span class="special">)</span></code>, and <code class="computeroutput"><span class="special">(</span><span class="identifier">body</span><span class="special">)</span></code>
because Doxygen preprocessor is not capable to handle Boost.Preprocessor
sequences).
</li><li class="listitem">
Rewritten entire documentation (now using Boost.QuickBook instead of
Doxygen).
</li></ol></div><p>
Release <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_3_469" target="_top">files</a>
and <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_3_469/doc/html/index.html" target="_top">documentation</a>.
</p></div><div class="section" title="Release 0.2.190"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.release_notes.release_0_2_190"></a><a class="link" href="#contract__.release_notes.release_0_2_190" title="Release 0.2.190">Release 0.2.190</a></h3></div></div></div><p>
November 21, 2009
</p><p>
Notes:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Compiled using both GCC (Linux and Cygwin) and MSVC (Windows XP).
</li><li class="listitem">
Required to use void to specify empty function argument list. This is
to comply with C++03 standard that does not allow to pass empty macro
parameters so it does not support empty preprocessor sequences <code class="computeroutput"><span class="special">()</span></code>.
</li></ol></div><p>
Release <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_2_190" target="_top">files</a>
and <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_2_190/doc/html/index.html" target="_top">documentation</a>.
</p></div><div class="section" title="Release 0.1.126"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.release_notes.release_0_1_126"></a><a class="link" href="#contract__.release_notes.release_0_1_126" title="Release 0.1.126">Release 0.1.126</a></h3></div></div></div><p>
June 17, 2009
</p><p>
Notes:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Completed first documentation draft.
</li></ol></div><p>
Release <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_1_126" target="_top">files</a>
and <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_1_126/doc/html/index.html" target="_top">documentation</a>.
</p></div><div class="section" title="Release 0.1.55"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.release_notes.release_0_1_55"></a><a class="link" href="#contract__.release_notes.release_0_1_55" title="Release 0.1.55">Release 0.1.55</a></h3></div></div></div><p>
April 19, 2009
</p><p>
Notes:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
Reorganized files to cleanup root directory.
</li><li class="listitem">
Added installation program.
</li></ol></div><p>
Release <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_1_55" target="_top">files</a>
and <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_1_55/doc/DBC_Documentation.txt" target="_top">documentation</a>.
</p></div><div class="section" title="Release 0.1.50"><div class="titlepage"><div><div><h3 class="title"><a name="contract__.release_notes.release_0_1_50"></a><a class="link" href="#contract__.release_notes.release_0_1_50" title="Release 0.1.50">Release 0.1.50</a></h3></div></div></div><p>
April 19, 2009
</p><p>
Notes:
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
First public release.
</li></ol></div><p>
Release <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_1_50" target="_top">files</a>
and <a class="ulink" href="http://contractpp.svn.sourceforge.net/viewvc/contractpp/releases/contractpp_0_1_50/README.txt" target="_top">documentation</a>.
</p></div></div><div class="section" title="Bibliography"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.bibliography"></a><a class="link" href="#contract__.bibliography" title="Bibliography">Bibliography</a></h2></div></div></div><p>
<a name="Bright04_anchor"></a>[Bright04] W. Bright. <a class="ulink" href="http://www.digitalmars.com/d/2.0/dbc.html" target="_top"><span class="emphasis"><em>Contract
Programming for the D Programming Language</em></span></a>. 2004.
</p><p>
<a name="Bright04b_anchor"></a>[Bright04b] W. Bright. <a class="ulink" href="http://www.digitalmars.com/ctg/contract.html" target="_top"><span class="emphasis"><em>Contract
Programming for the Digital Mars C++ Compiler</em></span></a>. 2004.
</p><p>
<a name="C2_anchor"></a>[C2] Aechmea. <a class="ulink" href="http://www.programmersheaven.com/app/news/DisplayNews.aspx?NewsID=3843" target="_top"><span class="emphasis"><em>C^2
Contract Programming add-on for C++</em></span></a>. 2005.
</p><p>
<a name="Chrome02_anchor"></a>[Chrome02] RemObjects. <a class="ulink" href="http://blogs.remobjects.com/blogs/mh/2008/05/01/p216" target="_top"><span class="emphasis"><em>Chrome:
Contract Programming for Object Pascal in .NET</em></span></a>. 2002.
</p><p>
<a name="Clarke06_anchor"></a>[Clarke06] L. A. Clarke and D. S. Rosenblum.
<a class="ulink" href="http://discovery.ucl.ac.uk/4991/1/4991.pdf" target="_top"><span class="emphasis"><em>A Historical
Perspective on Runtime Assertion Checking in Software Development</em></span></a>.
Newsletter ACM SIGSOFT Software Engineering Notes, 2006.
</p><p>
<a name="Cline90_anchor"></a>[Cline90] M. Cline and D. Lea. <span class="emphasis"><em>The Behaviour
of C++ Classes</em></span> and <a class="ulink" href="http://surface.syr.edu/cgi/viewcontent.cgi?article=1116&amp;context=eecs" target="_top"><span class="emphasis"><em>Using
Annotated C++</em></span></a>. Proc. of the Symposium on Object Oriented
Programming Emphasizing Practical Applications, Maris College, 1990.
</p><p>
<a name="Ellis90_anchor"></a>[Ellis90] M. A. Ellis and B. Stroustrup. <span class="emphasis"><em>The
Annotated C++ Reference Manual</em></span>. ANSI Base Document, Addison Wesley,
1990.
</p><p>
<a name="Gautron92_anchor"></a>[Gautron92] P. Gautron. <span class="emphasis"><em>An Assertion
Mechanism Based on Exceptions</em></span>. Fourth C++ Technical Conference,
1992.
</p><p>
<a name="Hoare73_anchor"></a>[Hoare73] C. A. R. Hoare. <span class="emphasis"><em>Hints on Programming
Language Design</em></span>. Stanford University Artificial Intelligence memo
AIM-224/STAN-CS-73-403, pages 193-216, 1973.
</p><p>
<a name="CodeContracts_anchor"></a>[CodeContracts] Microsoft Research. <a class="ulink" href="http://research.microsoft.com/en-us/projects/contracts/" target="_top"><span class="emphasis"><em>Code
Contracts: Design-By-Contract Programming for All .NET Programming Languages</em></span></a>.
2012.
</p><p>
<a name="iContract_anchor"></a>[iContract] O. Enseling. <a class="ulink" href="http://www.javaworld.com/javaworld/jw-02-2001/jw-0216-cooltools.html" target="_top"><span class="emphasis"><em>iContract:
Contract Programming for Java</em></span></a>. 2001.
</p><p>
<a name="Jcontract_anchor"></a>[Jcontract] Parasoft. <a class="ulink" href="http://www.parasoft.com/jsp/products/article.jsp?label=product_info_Jcontract" target="_top"><span class="emphasis"><em>Jcontract:
Contract Programming for Java</em></span></a>.
</p><p>
<a name="Lindrud04_anchor"></a>[Lindrud04] J. Lindrud. <a class="ulink" href="http://www.codeproject.com/Articles/8293/Design-by-Contract-in-C" target="_top"><span class="emphasis"><em>Design
by Contract in C++</em></span></a>. 2004.
</p><p>
<a name="Maley99_anchor"></a>[Maley99] D. Maley and I. Spence. <a class="ulink" href="http://www.computer.org/portal/web/csdl/doi/10.1109/TOOLS.1999.779000" target="_top"><span class="emphasis"><em>Emulating
Design by Contract in C++</em></span></a>. Proceedings of TOOLS, IEEE Computer
Society, 1999.
</p><p>
<a name="Meyer97_anchor"></a>[Meyer97] B. Meyer. <span class="emphasis"><em>Object Oriented
Software Construction</em></span>. Prentice-Hall, 2nd edition, 1997.
</p><p>
<a name="Mitchell02_anchor"></a>[Mitchell02] R. Mitchell and J. McKim. <span class="emphasis"><em>Design
by Contract, by Example</em></span>. Addison-Wesley, 2002.
</p><p>
<a name="N1613_anchor"></a>[N1613] T. Ottosen. <a class="ulink" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2004/n1613.pdf" target="_top"><span class="emphasis"><em>Proposal
to add Design by Contract to C++</em></span></a>. The C++ Standards Committee,
N1613, 2004.
</p><p>
<a name="N1653_anchor"></a>[N1653] C. Nelson. <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm" target="_top"><span class="emphasis"><em>Working
draft changes for C99 preprocessor synchronization</em></span></a>. C++
Standards Committee, N1653, 2004.
</p><p>
<a name="N1669_anchor"></a>[N1669] T. Ottosen. <a class="ulink" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2004/n1669.html" target="_top"><span class="emphasis"><em>Proposal
to add Contract Programming to C++ (revision 1)</em></span></a>. The C++
Standards Committee, N1669, 2004.
</p><p>
<a name="N1773_anchor"></a>[N1773] D. Abrahams, L. Crowl, T. Ottosen, and J.
Widman. <a class="ulink" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1773.html" target="_top"><span class="emphasis"><em>Proposal
to add Contract Programming to C++ (revision 2)</em></span></a>. The C++
Standards Committee, N1773, 2005.
</p><p>
<a name="N1866_anchor"></a>[N1866] L. Crowl and T. Ottosen. <a class="ulink" href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1866.html" target="_top"><span class="emphasis"><em>Proposal
to add Contract Programming to C++ (revision 3)</em></span></a>. The C++
Standards Committee, N1866, 2005.
</p><p>
<a name="N1895_anchor"></a>[N1895] H. Sutter and F. Glassborow. <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1895.pdf" target="_top"><span class="emphasis"><em>Delegating
Constructors (revision 2)</em></span></a>. C++ Standards Committee, N1895,
2005.
</p><p>
<a name="N1962_anchor"></a>[N1962] L. Crowl and T. Ottosen. <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1962.html" target="_top"><span class="emphasis"><em>Proposal
to add Contract Programming to C++ (revision 4)</em></span></a>. The C++
Standards Committee, N1962, 2006.
</p><p>
<a name="N2081_anchor"></a>[N2081] D. Gregor, B. Stroustrup. <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2081.pdf" target="_top"><span class="emphasis"><em>Concepts
(revision 1)</em></span></a>. The C++ Standards Committee, N2081, 2006.
</p><p>
<a name="N2914_anchor"></a>[N2914] P. Becker. <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2914.pdf" target="_top"><span class="emphasis"><em>Working
Draft, Standard for Programming Language C++</em></span></a>. The C++ Standards
Committee, N2914, 2009.
</p><p>
<a name="N2906_anchor"></a>[N2906] B. Stroustrup. <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2906.pdf" target="_top"><span class="emphasis"><em>Simplifying
the sue of concepts</em></span></a>. The C++ Standards Committee, N2906,
2009.
</p><p>
<a name="Rosenblum95_anchor"></a>[Rosenblum95] D. S. Rosenblum. <a class="ulink" href="http://www.cs.toronto.edu/~chechik/courses06/csc410/rosenblum_assert95.pdf" target="_top"><span class="emphasis"><em>A
practical Approach to Programming With Assertions</em></span></a>. IEEE
Transactions on Software Engineering, 1995.
</p><p>
<a name="SPARKAda_anchor"></a>[SPARKAda] Praxis. <a class="ulink" href="http://www.praxis-his.com/sparkada/language.asp" target="_top"><span class="emphasis"><em>SPARKAda
(Ada-like Language with Contract Programming)</em></span></a>.
</p><p>
<a name="SpecSharp_anchor"></a>[SpecSharp] Microsoft. <a class="ulink" href="http:://research.microsoft.com/en-us/projects/specsharp/" target="_top"><span class="emphasis"><em>Spec#
(C# Extension)</em></span></a>.
</p><p>
<a name="Stroustrup94_anchor"></a>[Stroustrup94] B. Stroustrup. <span class="emphasis"><em>The
Design and Evolution of C++</em></span>. Addison Wesley, 1994.
</p><p>
<a name="Stroustrup97_anchor"></a>[Stroustrup97] B. Stroustrup. <span class="emphasis"><em>The
C++ Programming Language</em></span>. Prentice-Hall, 2nd Edition, 1997.
</p><p>
<a name="Tandin04_anchor"></a>[Tandin04] A. Tandin. <a class="ulink" href="http://www.codeproject.com/KB/macros/DbC_and_Doxygen.aspx" target="_top"><span class="emphasis"><em>Design
by Contract macros for C++ and link to Doxygen</em></span></a>. 2004.
</p><p>
<a name="Wilson06_anchor"></a>[Wilson06] M. Wilson. <a class="ulink" href="http://www.artima.com/cppsource/deepspace.html" target="_top"><span class="emphasis"><em>Contract
Programming 101 - The Nuclear Reactor and the Deep Space Probe</em></span></a>.
The C++ Source, 2006.
</p></div><div class="section" title="Acknowledgments"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="contract__.acknowledgments"></a><a class="link" href="#contract__.acknowledgments" title="Acknowledgments">Acknowledgments</a></h2></div></div></div><p>
This section aims to recognize the contributions of <span class="emphasis"><em>all</em></span>
the different people that participated directly or indirectly to the design
and development of this library.
</p><p>
Sincere thanks to my parents for their support with my education and my studies
in computer science.
</p><p>
Sincere thanks to Marina for her kindness and continuous support.
</p><p>
Many thanks to Bertrand Meyer for his pioneering and thorough work on Contract
Programming in <a class="link" href="#Meyer97_anchor">[Meyer97]</a>.
</p><p>
Many thanks to Thorsten Ottosen for his work with <a class="link" href="#N1962_anchor">[N1962]</a>
(and previous revisions) and for clarifying the <a class="link" href="#N1962_anchor">[N1962]</a>
requirements directly with the library authors when needed.
</p><p>
Many thanks to Andrzej Krzemienski for reviewing earlier versions of this library
providing valuable insights, for exchanging ideas on implementing assertion
requirements, and for suggesting to support named parameters.
</p><p>
Many thanks to Vicente J. Botet Escriba for reviewing earlier versions of this
library providing valuable insights and for suggesting to sue <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">copy</span></code>.
</p><p>
Thanks to Steven Watanabe for providing valuable insights on C++ and for hinting
to use template meta-programming introspection to detect if a base class has
a given member function (technique which turned out to be essential to fully
automate subcontracting).
</p><p>
Thanks to Dave Abrahams for providing valuable comments on the library syntax
and especially on the syntax to support named parameters.
</p><p>
Thanks to David Maley for having shared source code form his inspiring work
in <a class="link" href="#Maley99_anchor">[Maley99]</a> on emulating Contract Programming
in C++.
</p><p>
Finally, many thanks to the entire <a class="ulink" href="http://www.boost.org" target="_top">Boost</a>
community and <a class="ulink" href="http://lists.boost.org" target="_top">mailing list</a> for
providing valuable comments about this library and great insights on the C++
programming language.
</p></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a id="ftn.contract__.introduction.f0" href="#contract__.introduction.f0" class="para">1</a>] </sup>
Design by Contract is a registered trademark of <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_Software" target="_top">Eiffel
Software</a>.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.getting_started.this_documentation.f0" href="#contract__.getting_started.this_documentation.f0" class="para">2</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Using Boost.Detail/LightweightTest
allows to add the examples to the library regression tests so to make sure
that they always compile and run correctly.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.getting_started.compilers_and_platforms.f0" href="#contract__.getting_started.compilers_and_platforms.f0" class="para">3</a>] </sup>
When using GCC to compile large projects that use this library, it
might be necessary to appropriately set the <code class="computeroutput"><span class="special">--</span><span class="identifier">param</span> <span class="identifier">gcc</span><span class="special">-</span><span class="identifier">min</span><span class="special">-</span><span class="identifier">expand</span></code>
option to avoid internal compiler errors due to excessive virtual memory
usage.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.getting_started.installation.f0" href="#contract__.getting_started.installation.f0" class="para">4</a>] </sup>
For convenience, a <code class="literal">Jamfile.v2</code> file is provided in the
example directory that can be used to compile and test all the examples
using <a class="ulink" href="http://www.boost.org/doc/libs/release/doc/html/jam.html" target="_top">Boost.Jam</a>.
However, it is not necessary to use <a class="ulink" href="http://www.boost.org/doc/libs/release/doc/html/jam.html" target="_top">Boost.Jam</a>
to compile code that uses this library.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.getting_started.installation.f1" href="#contract__.getting_started.installation.f1" class="para">5</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This library concatenates symbols
specified by programmers (e.g., the function name) with other symbols (e.g.,
special prefixes and line numbers) to make internal symbols with unique
names to avoid name clashes. These symbols are separated by the letter
<code class="computeroutput"><span class="identifier">X</span></code> when they are concatenated
so they read more easily during debugging (unfortunately, the underscore
character <code class="computeroutput"><span class="identifier">_</span></code> could not be
used instead of the letter <code class="computeroutput"><span class="identifier">X</span></code>
because if the original symbol already contained a leading or trailing
underscore, the concatenation could result in a symbol with double underscores
<code class="computeroutput"><span class="identifier">__</span></code> which is reserved by
the C++ standard). The <span class="quote">&#8220;<span class="quote">aux</span>&#8221;</span> symbols are internal to the implementation
of this library. The <span class="quote">&#8220;<span class="quote">detail</span>&#8221;</span> symbols are not officially part
of the library public interface and they are not documented however they
constitute a separate set of standalone libraries that could be added to
the library public interface in the future.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.costs.f0" href="#contract__.contract_programming_overview.costs.f0" class="para">6</a>] </sup>
This library macros always need to expand to generate the class and function
declarations even when contract compilation is disabled. That is why
there is a compile-time overhead, even if significantly smaller, also
when contracts are all disabled (in this case however there is zero run-time
overhead). The compilation time overhead when all contracts are turned
off could be further reduced by optimizing the library implementation
to not include internal headers that are not required when contracts
are off (this type of optimizations will be a major focus on future releases).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.free_function_calls.f0" href="#contract__.contract_programming_overview.free_function_calls.f0" class="para">7</a>] </sup>
In C++, a free function is any function that is not a member function.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.member_function_calls.f0" href="#contract__.contract_programming_overview.member_function_calls.f0" class="para">8</a>] </sup>
Static member functions cannot be virtual so they cannot be overridden
and they do not subcontract.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.destructor_calls.f0" href="#contract__.contract_programming_overview.destructor_calls.f0" class="para">9</a>] </sup>
For generality, this library does not require the destructor body to
not throw exceptions. However, in order to comply with the STL exception
safety requirements, destructors should never throw.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.destructor_calls.f1" href="#contract__.contract_programming_overview.destructor_calls.f1" class="para">10</a>] </sup>
In theory, destructors could have static postconditions (i.e., postconditions
that are not allowed to access the object which no longer exists after
destruction). Still destructors shall never have preconditions because
a destructor can be called at any point after the object is constructed
as long the class invariants hold. None of the Contract Programming
references that the authors have studied propose static postconditions
for destructor (neither <a class="link" href="#N1962_anchor">[N1962]</a>
nor <a class="link" href="#Meyer97_anchor">[Meyer97]</a>, but <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
has no static data member). Future revisions of this library might
implement destructor static postconditions (e.g., a destructor postconditions
of a class that counts object instances could assert that the instance
counter stored in a static data member should be decreased of one because
the object has been destructed, see also <a class="ulink" href="https://sourceforge.net/apps/trac/contractpp/ticket/41" target="_top">Ticket
41</a>).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.constant_correctness.f0" href="#contract__.contract_programming_overview.constant_correctness.f0" class="para">11</a>] </sup>
As usual in C++, constant-correctness can be enforced at compile-time only
as long as programmers do not use <code class="computeroutput"><span class="keyword">const_cast</span></code>
and <code class="computeroutput"><span class="keyword">mutable</span></code>.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.specification_vs__implementation.f0" href="#contract__.contract_programming_overview.specification_vs__implementation.f0" class="para">12</a>] </sup>
This is a major conceptual difference with respect to <a class="ulink" href="http://en.wikipedia.org/wiki/Defensive_programming" target="_top">Defensive
Programming</a> and using <code class="computeroutput"><span class="identifier">assert</span></code>
because they program assertions within the function body instead that with
the function declaration.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.contract_programming_overview.specification_vs__implementation.f1" href="#contract__.contract_programming_overview.specification_vs__implementation.f1" class="para">13</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> In theory, if C++ <a class="ulink" href="http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#45" target="_top">defect
45</a> were not fixed, this library could have generated a compile-time
error for preconditions that use non-public members.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.free_functions.f0" href="#contract__.tutorial.free_functions.f0" class="para">14</a>] </sup>
In the examples presented in this documentation, extra parenthesis are
in general avoided unless strictly required (for example, extra parenthesis
around fundamental types containing no symbol <code class="computeroutput"><span class="keyword">void</span></code>,
<code class="computeroutput"><span class="keyword">bool</span></code>, <code class="computeroutput"><span class="keyword">unsigned</span>
<span class="keyword">int</span> <span class="keyword">const</span></code>,
etc are always omitted). In the authors' opinion, the syntax is more readable
with lesser parenthesis. However, other programmers might find it more
readable to always specify extra parenthesis around result and parameter
types for consistency even when they are not strictly required.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.free_functions.f1" href="#contract__.tutorial.free_functions.f1" class="para">15</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This library uses preprocessor
meta-programming to parse declarations and contracts of classes and functions.
The preprocessor cannot parse a token if it is not known a priori or
if it contains symbols, unless such a token is wrapped within round parenthesis
<code class="computeroutput"><span class="special">()</span></code>. For example, the function
name is arbitrary, it cannot be known a priori, so it must always be
wrapped within parenthesis. If a type is a fundamental type then it is
known a priori (because it is composed of known C++ keywords <code class="computeroutput"><span class="keyword">int</span></code>, <code class="computeroutput"><span class="keyword">const</span></code>,
<code class="computeroutput"><span class="keyword">unsigned</span></code>, etc), and if the
fundamental type also contains no symbols (<code class="computeroutput"><span class="special">&amp;</span></code>,
<code class="computeroutput"><span class="special">*</span></code>, etc) then the parenthesis
around such a type are optional.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.free_functions.f2" href="#contract__.tutorial.free_functions.f2" class="para">16</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> It would be possible to modify
the library syntax to make parameter names optional but that will complicate
the library implementation without adding any feature for programmers.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.free_functions.f3" href="#contract__.tutorial.free_functions.f3" class="para">17</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Unfortunately, it is not possible
to specify an empty parameter list simply as <code class="literal"><span class="emphasis"><em>result-type
function-name </em></span></code><code class="computeroutput"><span class="special">(</span>
<span class="special">)</span></code> because the preprocessor can only
parse <code class="computeroutput"><span class="special">(</span> <span class="special">)</span></code>
if empty macro parameters are supported. Empty macro parameters together
with variadic macros where added to <a class="ulink" href="http://en.wikipedia.org/wiki/C99" target="_top">C99</a>
and the preferred syntax of this library uses variadic macros. However,
not all compilers (notably MSVC) that support variadic macros also correctly
support empty macro parameters so <code class="computeroutput"><span class="special">(</span>
<span class="keyword">void</span> <span class="special">)</span></code>
is always used instead of <code class="computeroutput"><span class="special">(</span> <span class="special">)</span></code> to increase portability.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.free_functions.f4" href="#contract__.tutorial.free_functions.f4" class="para">18</a>] </sup>
Note that the <code class="computeroutput"><span class="keyword">auto</span></code> storage
classifier in deprecated by <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
so it should be used with the usual care when writing programs that should
be portable from <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
to <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.free_functions.f5" href="#contract__.tutorial.free_functions.f5" class="para">19</a>] </sup>
An MSVC preprocessor bug requires to use at least one space or newline
to separate a parameter name from its type even when the parameter type
is wrapped within parenthesis.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.postconditions__result_and_old_values_.f0" href="#contract__.tutorial.postconditions__result_and_old_values_.f0" class="para">20</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
<code class="computeroutput"><span class="keyword">auto</span></code> declaration syntax was
adopted for postcondition return value declarations however this library
knows the result type because it is specified in the function declaration
within the macros so no type deduction is actually used to implement auto
declarations of return values. Similarly, the <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
<code class="computeroutput"><span class="keyword">auto</span></code> declaration syntax was
adopted for postcondition old value declarations however this library deduces
the type of old value expressions using <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
so no <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
feature is actually needed (in this case programmers can optionally specify
the old value type so to not use <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/typeof" target="_top">Boost.Typeof</a>
as explained in the <a class="link" href="#contract__.advanced_topics" title="Advanced Topics">Advanced
Topics</a> section).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.postconditions__result_and_old_values_.f1" href="#contract__.tutorial.postconditions__result_and_old_values_.f1" class="para">21</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This is also the syntax specified
by <a class="link" href="#N1962_anchor">[N1962]</a> for the <code class="computeroutput"><span class="identifier">oldof</span></code>
operator which is the equivalent of the <code class="computeroutput"><span class="identifier">CONTRACT_OLDOF</span></code>
macro.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.postconditions__result_and_old_values_.f2" href="#contract__.tutorial.postconditions__result_and_old_values_.f2" class="para">22</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This library macros could
have been implemented to allow to mix the order of some tokens (preconditions
and postconditions, <code class="computeroutput"><span class="keyword">volatile</span></code>
and <code class="computeroutput"><span class="keyword">const</span></code>). However, that
would have complicated the macro implementation without any added functionality
for the user.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.classes_and_class_invariants.f0" href="#contract__.tutorial.classes_and_class_invariants.f0" class="para">23</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> There is no need for a <code class="computeroutput"><span class="identifier">CONTRACT_STRUCT</span></code> macro because this library
macros can parse the class declaration and distinguish between the <code class="computeroutput"><span class="keyword">struct</span></code> and <code class="computeroutput"><span class="keyword">class</span></code>
specifiers.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.classes_and_class_invariants.f1" href="#contract__.tutorial.classes_and_class_invariants.f1" class="para">24</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The authors have not fully
investigated if this library could be extended to specify contracts for
unions. It is possible that future revisions of this library will support
contracts for unions (see also <a class="ulink" href="http://sourceforge.net/apps/trac/contractpp/ticket/50" target="_top">Ticket
50</a>).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.constructors.f0" href="#contract__.tutorial.constructors.f0" class="para">25</a>] </sup>
<span class="bold"><strong>Rationale</strong></span> This library needs to know each
member access level because in Contract Programming only public members
are supposed to check class invariants while protected and private members
only check preconditions and postconditions but not the class invariants.
Unfortunately, in C++ it is not possible for a member to introspect its
access level using template meta-programming. Therefore, this library requires
the access level to be specified within the macros and it uses preprocessor
meta-programming to detect it. Furthermore, given that the access level
is has to be specified, the <code class="computeroutput"><a class="link" href="#CONTRACT_FUNCTION" title="Macro CONTRACT_FUNCTION">CONTRACT_FUNCTION</a></code>
macro also uses it to differentiate between free and member functions so
no additional macro <code class="computeroutput"><span class="identifier">CONTRACT_MEMBER</span></code>
is needed.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.constructors.f1" href="#contract__.tutorial.constructors.f1" class="para">26</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Member initializers are specified
after the preconditions and postconditions because they are part of the
constructor definition while preconditions and postconditions are part
of the constructor declaration.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.destructors.f0" href="#contract__.tutorial.destructors.f0" class="para">27</a>] </sup>
Future revisions of this library might implement static postconditions
for destructors (see the <a class="link" href="#contract__.contract_programming_overview.destructor_calls" title="Destructor Calls">Destructor
Calls</a> section).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.inheritance_and_subcontracting.f0" href="#contract__.tutorial.inheritance_and_subcontracting.f0" class="para">28</a>] </sup>
<span class="bold"><strong>Rationale</strong></span>. In this case, the library
implementation will recursively check contracts of the overriding function
forever (in all other cases, this library is able to avoid infinite recursions
due to contract checking).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.class_templates.f0" href="#contract__.tutorial.class_templates.f0" class="para">29</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The library must know if
the enclosing scope is a template so it knows when to prefix nested type
expressions with <code class="computeroutput"><span class="keyword">typename</span></code>
(because <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
does not allow to use <code class="computeroutput"><span class="keyword">typename</span></code>
outside templates). This constraints could be relaxed on future revisions
of this library for <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
compilers (because <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
allows to use <code class="computeroutput"><span class="keyword">typename</span></code> more
freely). Earlier versions of this library did not require to use the
special <code class="computeroutput"><span class="identifier">_TPL</span></code> macros within
templates because the library internally implemented every contracted
function using a template function, possibly with dummy template parameters,
even if the original function was not a template so <code class="computeroutput"><span class="keyword">typename</span></code>
could always be used by the library. The dummy template parameters were
hidden to the user so this approach did not change the user API and had
the benefit of not requiring the <code class="computeroutput"><span class="identifier">_TPL</span></code>
macros. However, this approach increased compilation time because of
the extra templates that it introduced so the current revision of the
library uses the <code class="computeroutput"><span class="identifier">_TPL</span></code>
macros.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.forward_declarations_and_body_definitions.f0" href="#contract__.tutorial.forward_declarations_and_body_definitions.f0" class="para">30</a>] </sup>
In principle, this library supports <code class="computeroutput"><span class="keyword">export</span></code>
templates that can be used to program template definitions separately from
their declarations and in files that can be pre-compiled. However, <code class="computeroutput"><span class="keyword">export</span></code> templates are not supported by most
<a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a> compilers
(in fact, <a class="ulink" href="http://www.comeaucomputing.com/4.0/docs/userman/export.html" target="_top">Comeau</a>
might be the only compiler that supports them), they were removed from
<a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>, and
they are an untested feature of this library. Instead of using <code class="computeroutput"><span class="keyword">export</span></code> templates, it is common practise
in C++ to program both template declarations and definitions together so
they can be compiled correctly. In this example, the authors have used
a separate header file <code class="computeroutput"><span class="special">...</span><span class="identifier">_impl</span><span class="special">.</span><span class="identifier">hpp</span></code> to logically separate template declarations
and definitions but the header is included at the bottom of the declaration
header file so the definitions are always available together with their
declarations.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.forward_declarations_and_body_definitions.f1" href="#contract__.tutorial.forward_declarations_and_body_definitions.f1" class="para">31</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Four different body macros
are needed because contracts are disabled differently for the different
type of functions. For example, disabling preconditions and postconditions
turns off contracts for free functions but not for member functions, disabling
class invariants turns off contracts for destructors but not for constructors,
etc.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.forward_declarations_and_body_definitions.f2" href="#contract__.tutorial.forward_declarations_and_body_definitions.f2" class="para">32</a>] </sup>
Some compilers accept to repeat template parameter names in the constructor
and destructor names. However, this is not <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
compliant (and, for example, it was fixed in more recent versions of GCC)
therefore programmers are advised to specify the template parameter names
only for the class type and not for the constructor and destructor names.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.tutorial.forward_declarations_and_body_definitions.f3" href="#contract__.tutorial.forward_declarations_and_body_definitions.f3" class="para">33</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This limitation comes from
the fact that <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
does not support delegating constructors. If member initializers are
specified within the contract, the deferred body will not compile when
contract compilation is turned off by the configuration macros. If instead
member initializers are specified with the deferred body definition,
the deferred body will not compile when contract compilation is turned
on by the configuration macros. There is no way to reconcile these two
conditions without delegating constructors, so definitions cannot be
deferred for constructors that specify member initializers. This limitation
could be removed in future revisions of this library for <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
compilers that support delegating constructors (see also <a class="ulink" href="http://sourceforge.net/apps/trac/contractpp/ticket/51" target="_top">Ticket
51</a>.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.commas_and_leading_symbols_in_macros.f0" href="#contract__.advanced_topics.commas_and_leading_symbols_in_macros.f0" class="para">34</a>] </sup>
Note that for the preprocessor a number with decimal period <code class="computeroutput"><span class="number">1.23</span></code>, <code class="computeroutput"><span class="number">0.12</span></code>,
<code class="computeroutput"><span class="special">.</span><span class="number">34</span></code>
is considered a symbol (because its concatenation will not result in a
valid macro identifier).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.commas_and_leading_symbols_in_macros.f1" href="#contract__.advanced_topics.commas_and_leading_symbols_in_macros.f1" class="para">35</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This limitation is introduced
by the need to support also the sequence syntax for preprocessor without
variadic macros (see the <a class="link" href="#contract__.no_variadic_macros" title="No Variadic Macros">No
Variadic Macros</a> section).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.static_assertions.f0" href="#contract__.advanced_topics.static_assertions.f0" class="para">36</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
supports <span class="emphasis"><em>assertion labeling</em></span> to further documenting
assertions. However, when designing this library for C++, the authors judged
that it is sufficient to add a short code comment after each assertion
to achieve a similar effect.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.constant_assertions.f0" href="#contract__.advanced_topics.constant_assertions.f0" class="para">37</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The library needs to know
at least the variable name in order to make it constant. There is no
way for this library to know the name of a global variable that is implicitly
accessible from the contract assertion scope so such a variable cannot
be automatically made constant. Non-static data members are automatically
made constant by making constant the member function that checks the
contract, but that does not apply to static data members. Not even <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a> lambda implicit
captures could be used in this context because they make variables constant
only when captured by value and that introduces a <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/utility/CopyConstructible.html" target="_top"><code class="literal">CopyConstructible</code></a>
requirement of the captured variable types.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.assertion_statements.f0" href="#contract__.advanced_topics.assertion_statements.f0" class="para">38</a>] </sup>
Assertion statements might be especially useful because contracts appear
with the class and function declarations usually in header files where
<code class="computeroutput"><span class="keyword">using</span></code> directives and <code class="computeroutput"><span class="keyword">namespace</span></code> aliases should only be used with
extreme care and, for example, at local scope as assertion statements allow
to do.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.assertion_requirements.f0" href="#contract__.advanced_topics.assertion_requirements.f0" class="para">39</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The assertion requirement
syntax takes a constant boolean expression instead of a nullary boolean
meta-function because the authors have found no reason to use a meta-function
in this context. Furthermore, constant boolean expressions can be manipulated
via the usual operators <code class="computeroutput"><span class="keyword">not</span></code>,
<code class="computeroutput"><span class="keyword">and</span></code>, etc, therefore more
naturally than boolean meta-functions which need to use <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">not_</span></code>, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">and_</span></code>,
etc instead.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.assertion_requirements.f1" href="#contract__.advanced_topics.assertion_requirements.f1" class="para">40</a>] </sup>
Future revisions of this library might provide wrappers that program contracts
for the STL in appropriate header files <code class="literal">contract/std/vector.hpp</code>,
<code class="literal">contract/std/algorithm.hpp</code>, etc (see also <a class="ulink" href="http://www.sgi.com/tech/stl/" target="_top">SGI
STL</a> and <a class="ulink" href="http://sourceforge.net/apps/trac/contractpp/ticket/47" target="_top">Ticket
47</a>). However, given that STL implementations are usually considered
to be <span class="quote">&#8220;<span class="quote">correct</span>&#8221;</span>, it is not clear if STL class invariants and
postconditions would add any value, maybe programmers would only find STL
preconditions useful.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.assertion_requirements.f2" href="#contract__.advanced_topics.assertion_requirements.f2" class="para">41</a>] </sup>
Assertion requirements where first introduced by this library and they
are not supported by <a class="link" href="#N1962_anchor">[N1962]</a>, <a class="ulink" href="http://dlang.org" target="_top">D</a>, or <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
(even if they all allow to write contracts for templates). Based on the
authors' experience, assertion requirements are necessary for a language
that make extensive use of templates like C++. Furthermore, C++ does not
automatically define equality operators <code class="computeroutput"><span class="special">==</span></code>
while it automatically defines copy constructors and that make the use
of the assertion requirements for <a class="ulink" href="http://www.sgi.com/tech/stl/EqualityComparable.html" target="_top"><code class="literal">EqualityComparable</code></a>
a rather common practise (in <a class="ulink" href="http://en.wikipedia.org/wiki/Eiffel_(programming_language)" target="_top">Eiffel</a>
instead types can be both copied and compared for equality by default).
It has been argued that it is not possible to check a program for correctness
if types that are copyable cannot also be compared for equality and the
authors experience with programming contracts confirms such an argument.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.assertion_requirements.f3" href="#contract__.advanced_topics.assertion_requirements.f3" class="para">42</a>] </sup>
As of <a class="ulink" href="http://www.boost.org" target="_top">Boost</a> 1.50, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span></code> and similar traits always
return true for an STL container even if the value type of the container
does not have an operator <code class="computeroutput"><span class="special">==</span></code>.
This is arguably a defect of the STL that always defines an operator <code class="computeroutput"><span class="special">==</span></code> for its containers even when a container
template is instantiated with a value type that has no operator <code class="computeroutput"><span class="special">==</span></code>, in which case the container operator
<code class="computeroutput"><span class="special">==</span></code> will produce a compiler
error (the STL should instead use <a class="ulink" href="http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error" target="_top">SFINAE</a>
to disable the declaration of the container operator <code class="computeroutput"><span class="special">==</span></code>
when the value type has no operator <code class="computeroutput"><span class="special">==</span></code>).
Future versions of <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/type_traits" target="_top">Boost.TypeTraits</a>
will probably specialize <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">has_equal_to</span></code>
and similar traits to work around this behaviour of the STL. In the meanwhile,
programmers can specialize these traits themselves if needed:
</p><pre class="programlisting"><span class="comment">// Header: fix_has_equal_to.hpp</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">has_equal_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">namespace</span> <span class="identifier">boost</span>
<span class="special">{</span>
<span class="comment">// STL vector specializations.</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">has_equal_to</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
<span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">has_equal_to</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">has_equal_to</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
<span class="special">...</span> <span class="comment">// Specialize `has_equal_to` for more STL containers.</span>
<span class="special">}</span> <span class="comment">// namespace</span>
</pre><p>
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.assertion_requirements.f4" href="#contract__.advanced_topics.assertion_requirements.f4" class="para">43</a>] </sup>
<a class="link" href="#N1866_anchor">[N1866]</a>, an earlier version of <a class="link" href="#N1962_anchor">[N1962]</a>, introduced the notion of <span class="emphasis"><em>importance
ordering</em></span> that could be used to selectively disable assertions
that where too expensive computationally. Important ordering was then dropped
by <a class="link" href="#N1962_anchor">[N1962]</a>. Among other things, assertion
requirements can be used to achieve the importance ordering functionality.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.old_of_requirements.f0" href="#contract__.advanced_topics.old_of_requirements.f0" class="para">44</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The result type needs to be
copyable in order for the function itself to return a value so this library
can always evaluate return value declarations.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.old_and_result_value_copies.f0" href="#contract__.advanced_topics.old_and_result_value_copies.f0" class="para">45</a>] </sup>
Currently, it is not possible to force constant-correctness of the expression
passed to the <code class="computeroutput"><a class="link" href="#CONTRACT_OLDOF" title="Macro CONTRACT_OLDOF">CONTRACT_OLDOF</a></code>
macro. Future revisions of this library will support <code class="computeroutput"><span class="identifier">CONTRACT_OLDOF</span>
<span class="keyword">const</span><span class="special">(</span>
<span class="special">...</span> <span class="special">)</span>
<span class="special">...</span></code> to allow to make constant all
variables (including global, static, etc) used by old value expressions
(see also <a class="ulink" href="http://sourceforge.net/apps/trac/contractpp/ticket/52" target="_top">Ticket
52</a>).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.static_member_functions.f0" href="#contract__.advanced_topics.static_member_functions.f0" class="para">46</a>] </sup>
Static class invariants are not part of <a class="link" href="#N1962_anchor">[N1962]</a>
and they were first introduced by this library.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.volatile_member_functions.f0" href="#contract__.advanced_topics.volatile_member_functions.f0" class="para">47</a>] </sup>
Volatile class invariants are not part of <a class="link" href="#N1962_anchor">[N1962]</a>
and they were first introduced by this library. It is not clear if there
are real applications for volatile class invariants mainly because real
applications of <code class="computeroutput"><span class="keyword">volatile</span></code> itself
are not clear in C++. One very interesting use of <code class="computeroutput"><span class="keyword">volatile</span></code>
has been to <a class="ulink" href="http://www.drdobbs.com/cpp/184403766" target="_top">avoid race
conditions</a> in concurrent programming (but contracts are not useful
for such an application of <code class="computeroutput"><span class="keyword">volatile</span></code>).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.operators.f0" href="#contract__.advanced_topics.operators.f0" class="para">48</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The comma operator cannot be
specified using the comma symbol as in <code class="computeroutput"><span class="keyword">operator</span><span class="special">(,)(</span><span class="identifier">my_comma_operator</span><span class="special">)</span></code> because the preprocessor uses commas to
separate macro parameters so it is not possible to distinguish that from
an implicit type conversion operator like <code class="computeroutput"><span class="keyword">operator</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">&gt;)(</span><span class="identifier">std_vector</span><span class="special">)</span></code> (note that the operator name is arbitrary
so it also cannot be used to distinguish these two cases).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.operators.f1" href="#contract__.advanced_topics.operators.f1" class="para">49</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> C++ automatically promotes
memory member operators to static members so the <code class="computeroutput"><span class="keyword">static</span></code>
keyword is optional for these member operators. However, this library cannot
inspect the operator symbol using the preprocessor to check if the operator
is a memory member operator or not because the symbol contains non-alphanumeric
tokens (which cannot be concatenated by the preprocessor). Therefore, this
library always requires memory member operators to be explicitly declared
as static member functions.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.exception_specifications_and_function_try_blocks.f0" href="#contract__.advanced_topics.exception_specifications_and_function_try_blocks.f0" class="para">50</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> <a class="link" href="#N1962_anchor">[N1962]</a>
specifies that function-try blocks should only apply to the body code and
not to the contract code. No explicit requirement is stated in <a class="link" href="#N1962_anchor">[N1962]</a>
for exception specifications but the authors have decided to adopt the
same requirement that applies to function-try blocks (because it seemed
of little use for the contract to throw an exception just so it is handled
by the exception specification).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f0" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f0" class="para">51</a>] </sup>
<a class="link" href="#N1962_anchor">[N1962]</a> does not allow to configure
class invariant broken handlers differently for entry, exit, and throw.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f1" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f1" class="para">52</a>] </sup>
The <code class="computeroutput"><span class="identifier">contract</span><span class="special">::</span><span class="identifier">from</span></code> parameter was not part of <a class="link" href="#N1962_anchor">[N1962]</a> contract broken handlers but the
proposal hinted that it might be needed (need that was confirmed by the
implementation of this library).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f2" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f2" class="para">53</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Exceptions are used to signal
a contract assertion failure because it is not possible to directly call
the contract broken handler (<code class="computeroutput"><a class="link" href="#contract.precondition_broken" title="Function precondition_broken">contract::precondition_broken</a></code>,
etc) instead of throwing the exception in oder to properly implement subcontracting.
For example, if an overriding precondition fails but the overridden precondition
is true then the library will not call the broken handler even if the overriding
precondition threw an exception (as required by subcontracting). Contract
assertion failures are critical error conditions so it is actually natural
that the library uses exceptions to signal them (note that the library
will always handle the exceptions by calling the contract broken handlers
which terminate the program by default so the fact that the library signals
contract assertion failures using exceptions does not imply that an exception
will be thrown if a contract assertion fails, that is entirely decided
by the implementation of the broken handlers).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f3" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f3" class="para">54</a>] </sup>
The assertion number is meaningful only within a specific handler.
For example, if assertion number <code class="computeroutput"><span class="number">2</span></code>
failed within the class invariant broken handler that mean that the
class invariant number <code class="computeroutput"><span class="number">2</span></code>
failed. Therefore, the assertion number is not useful if a single handler
is programmed for all types of contracts because such an handler can
no longer distinguish between class invariants, preconditions, postconditions,
etc.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f4" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f4" class="para">55</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Threating an exception thrown
while evaluating an assertion as a failure of the contract assertion is
a clear policy established by this library under the principle that a contract
assertion fails unless it is evaluated to be true. <a class="link" href="#N1962_anchor">[N1962]</a>
does not completely clarify this point.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f5" href="#contract__.advanced_topics.contract_broken_handlers__throw_on_failure_.f5" class="para">56</a>] </sup>
In this example, contract failures from destructors are logged and then
simply ignored. That might be acceptable in this simple example but it
is probably a very bad idea in general.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.virtual_specifiers.f0" href="#contract__.virtual_specifiers.f0" class="para">57</a>] </sup>
This library declares special member functions to <span class="quote">&#8220;<span class="quote">tag</span>&#8221;</span> virtual
traits of a given member function in a base class (if it is <code class="computeroutput"><span class="keyword">virtual</span></code>, <code class="computeroutput"><span class="identifier">final</span></code>,
etc). Then template meta-programming introspection is used by the derived
class to inspect virtual trait in its base classes and generate compiler
errors if the virtual specifiers are not satisfied. These techniques do
not use any <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
feature however, future revisions of this library might use <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B11" target="_top">C++11</a>
native support for virtual specifiers so to eliminate the extra compilation
time required by template meta-programming introspection and correct a
number of bugs associated with the current implementation of virtual specifiers
in this library (see also <a class="ulink" href="http://sourceforge.net/apps/trac/contractpp/ticket/53" target="_top">Ticket
53</a>, <a class="ulink" href="http://sourceforge.net/apps/trac/contractpp/ticket/53" target="_top">Ticket
55</a>, and <a class="ulink" href="http://sourceforge.net/apps/trac/contractpp/ticket/53" target="_top">Ticket
56</a>).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.named_function_parameters.f0" href="#contract__.named_parameters.named_function_parameters.f0" class="para">58</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> C++ cannot express the semantics
that an output parameter should be written and never read within a function
because references can always be both written and read.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.member_function_parameters.f0" href="#contract__.named_parameters.member_function_parameters.f0" class="para">59</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This library syntax supports
named and deduced parameters for operators. However, <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
does not compile when used with operators because of a bug (<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
documentation claims support for operators but later revisions of <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
no longer compile when operators are used). If <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
were to be fixed to work with operators then this library named and deduced
parameters should also work with operators.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.member_function_parameters.f1" href="#contract__.named_parameters.member_function_parameters.f1" class="para">60</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> A macro <code class="computeroutput"><a class="link" href="#CONTRACT_PARAMETER_BODY" title="Macro CONTRACT_PARAMETER_BODY">CONTRACT_PARAMETER_BODY</a></code>
different from <code class="computeroutput"><a class="link" href="#CONTRACT_MEMBER_BODY" title="Macro CONTRACT_MEMBER_BODY">CONTRACT_MEMBER_BODY</a></code>
and <code class="computeroutput"><a class="link" href="#CONTRACT_FREE_BODY" title="Macro CONTRACT_FREE_BODY">CONTRACT_FREE_BODY</a></code>
is necessary because named parameters will still be enabled even when contracts
are turned off using <code class="computeroutput"><a class="link" href="#CONTRACT_CONFIG_NO_PRECONDITIONS" title="Macro CONTRACT_CONFIG_NO_PRECONDITIONS">CONTRACT_CONFIG_NO_PRECONDITIONS</a></code>,
etc.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.constructor_parameters.f0" href="#contract__.named_parameters.constructor_parameters.f0" class="para">61</a>] </sup>
Arguably, this library offers a better syntax than <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
for constructor named and deduced parameters (because <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
requires boiler-plate code and an extra base class in order to handle constructors).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.constructor_parameters.f1" href="#contract__.named_parameters.constructor_parameters.f1" class="para">62</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This limitation comes from
the lacks of delegating constructors in <a class="ulink" href="http://en.wikipedia.org/wiki/C%2B%2B" target="_top">C++03</a>
(as with all other limitations of this library related to member initializers).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.class_template_parameters.f0" href="#contract__.named_parameters.class_template_parameters.f0" class="para">63</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This library only supports
named and deduced type template parameter because it internally uses
<a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
and <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
does not support non-type template parameters. However, this library
syntax would support named and deduced value template parameters and
template template parameters if these were ever supported by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
(see template parameters within the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section). Named and deduced value template parameters can be emulated
by wrapping their values into types (using <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">int_</span></code>,
<code class="computeroutput"><span class="identifier">boos</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">bool_</span></code>, etc) at the cost of a somewhat
cumbersome syntax.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.class_template_parameters.f1" href="#contract__.named_parameters.class_template_parameters.f1" class="para">64</a>] </sup>
Arguably, this library offers a better syntax than <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
for named and deduced template parameters (because <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
requires boiler-plate code and the additional argument packing types to
be programmed manually).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.class_template_parameters.f2" href="#contract__.named_parameters.class_template_parameters.f2" class="para">65</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This syntax was designed so
it can support non-type template parameters if this library and <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
were ever extended to support value template parameters and template template
parameters (see template parameters in the <a class="link" href="#contract__.grammar" title="Grammar">Grammar</a>
section).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.class_template_parameters.f3" href="#contract__.named_parameters.class_template_parameters.f3" class="para">66</a>] </sup>
This named and deduced parameter syntax is not entirely ideal because it
uses angular parenthesis <code class="computeroutput"><span class="identifier">py</span><span class="special">::</span><span class="identifier">ClassType_</span><span class="special">&lt;</span><span class="identifier">bx</span><span class="special">&gt;</span></code> instead of the more readable assignment
operator <code class="computeroutput"><span class="identifier">py</span><span class="special">::</span><span class="identifier">ClassType_</span> <span class="special">=</span>
<span class="identifier">bx</span></code> to name the arguments (but
that is how <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
is implemented and also this library authors see no way to implement the
assignment operator syntax for named and deduced template parameters).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.named_parameters.parameter_identifiers.f0" href="#contract__.named_parameters.parameter_identifiers.f0" class="para">67</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> The ability to specify the
parameter identifier (or tag) namespace is offered because it is offered
by <a class="ulink" href="http://www.boost.org/doc/libs/release/libs/parameter" target="_top">Boost.Parameter</a>
and it gives programmers greater control. However, it should be rarely
if ever needed because this library provides the [macro CONTRACT_PARAMETER_TYPEOF
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.grammar.f0" href="#contract__.grammar.f0" class="para">68</a>] </sup>
Usually, the complexity of C++ definitions is greater than the complexity
of C++ declaration and the fact that this library macros only affect declarations
would help by preserving the usefulness of the compiler error messages
for the definition code. However, this library aims to make declarations
more complex by adding program specifications to them (preconditions, postconditions,
etc). Therefore, it can no longer be argued that declarations are significantly
simpler than definitions and it would be rather helpful to have sensible
compiler error messages at least for the declarations with contracts.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.grammar.differences_with_c___syntax.f0" href="#contract__.grammar.differences_with_c___syntax.f0" class="para">69</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> This library macros could be
implemented to allow to specify syntactic elements in different orders
but that would complicate the macro implementation and this grammar with
no additional feature for the user.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.grammar.function_and_operator_names.f0" href="#contract__.grammar.function_and_operator_names.f0" class="para">70</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Within macros a comma <code class="computeroutput"><span class="special">,</span></code> has the special meaning of separating
the macro parameters so it cannot be used to indicate the comma operator
otherwise <code class="computeroutput"><span class="keyword">operator</span><span class="special">(,)(</span><span class="identifier">mycomma</span><span class="special">)</span></code>
and <code class="computeroutput"><span class="keyword">operator</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;)(</span><span class="identifier">stdmap</span><span class="special">)</span></code> could not be distinguished from one another
by the preprocessor.
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.grammar.terminals.f0" href="#contract__.grammar.terminals.f0" class="para">71</a>] </sup>
The C++ preprocessor cannot concatenate <code class="computeroutput"><span class="number">1.23</span></code>
because it contains the <code class="computeroutput"><span class="special">.</span></code>
symbol (even if that symbol is technically not the leading symbol). The
precise preprocessor requirement is that the concatenated symbol must be
a valid macro identifier and concatenating <code class="computeroutput"><span class="number">1.23</span></code>
with any token will never give a valid macro identifier because of the
presence of the dot symbol <code class="computeroutput"><span class="special">.</span></code>
(e.g., <code class="computeroutput"><span class="identifier">XYZ</span> <span class="error">#</span><span class="error">#</span> <span class="number">1.23</span></code> gives
<code class="computeroutput"><span class="identifier">XYZ1</span><span class="special">.</span><span class="number">23</span></code> which is not a valid macro identifier).
</p></div><div class="footnote"><p><sup>[<a id="ftn.contract__.no_variadic_macros.commas_and_leading_symbols_in_macros.f0" href="#contract__.no_variadic_macros.commas_and_leading_symbols_in_macros.f0" class="para">72</a>] </sup>
<span class="bold"><strong>Rationale.</strong></span> Using variadic macros, the
preprocessor can automatically determine the number of commas within a
tuple but without variadic macros that is no longer possible so programmers
must manually specify the number of commas.
</p></div></div></div></body></html>
Reference in New Issue View Git Blame Copy Permalink