ceph/src/boost/libs/local_function/doc/html/boost_localfunction/examples.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Examples</title>
   5 <link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
   7 <link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Boost.LocalFunction 1.0.0">
   8 <link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.LocalFunction 1.0.0">
   9 <link rel="prev" href="advanced_topics.html" title="Advanced Topics">
  10 <link rel="next" href="alternatives.html" title="Annex: Alternatives">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
  15 <td align="center"><a href="../../../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="advanced_topics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alternatives.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section">
  26 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
  27 <a name="boost_localfunction.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
  28 </h2></div></div></div>
  29 <div class="toc"><dl class="toc">
  30 <dt><span class="section"><a href="examples.html#boost_localfunction.examples.gcc_lambdas__without_c__11_">GCC
  31       Lambdas (without C++11)</a></span></dt>
  32 <dt><span class="section"><a href="examples.html#boost_localfunction.examples.constant_blocks">Constant
  33       Blocks</a></span></dt>
  34 <dt><span class="section"><a href="examples.html#boost_localfunction.examples.scope_exits">Scope Exits</a></span></dt>
  35 <dt><span class="section"><a href="examples.html#boost_localfunction.examples.boost_phoenix_functions">Boost.Phoenix
  36       Functions</a></span></dt>
  37 <dt><span class="section"><a href="examples.html#boost_localfunction.examples.closures">Closures</a></span></dt>
  38 <dt><span class="section"><a href="examples.html#boost_localfunction.examples.gcc_nested_functions">GCC
  39       Nested Functions</a></span></dt>
  40 <dt><span class="section"><a href="examples.html#boost_localfunction.examples.n_papers">N-Papers</a></span></dt>
  41 </dl></div>
  42 <p>
  43       This section lists some examples that use this library.
  44     </p>
  45 <div class="section">
  46 <div class="titlepage"><div><div><h3 class="title">
  47 <a name="boost_localfunction.examples.gcc_lambdas__without_c__11_"></a><a class="link" href="examples.html#boost_localfunction.examples.gcc_lambdas__without_c__11_" title="GCC Lambdas (without C++11)">GCC
  48       Lambdas (without C++11)</a>
  49 </h3></div></div></div>
  50 <p>
  51         Combing local functions with the non-standard <a href="http://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html" target="_top">statement
  52         expression</a> extension of the GCC compiler, it is possible to implement
  53         lambda functions for GCC compilers even without <a href="http://www.open-std.org/JTC1/SC22/WG21/" target="_top">C++11</a>
  54         support.
  55       </p>
  56 <div class="warning"><table border="0" summary="Warning">
  57 <tr>
  58 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../doc/src/images/warning.png"></td>
  59 <th align="left">Warning</th>
  60 </tr>
  61 <tr><td align="left" valign="top"><p>
  62           This code only works on compilers that support GCC statement expression
  63           extension or that support <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
  64           lambda functions</a>.
  65         </p></td></tr>
  66 </table></div>
  67 <p>
  68         For example (see also <a href="../../../example/gcc_lambda.cpp" target="_top"><code class="literal">gcc_lambda.cpp</code></a>
  69         and <a href="../../../example/gcc_cxx11_lambda.cpp" target="_top"><code class="literal">gcc_cxx11_lambda.cpp</code></a>):
  70       </p>
  71 <div class="informaltable"><table class="table">
  72 <colgroup>
  73 <col>
  74 <col>
  75 </colgroup>
  76 <thead><tr>
  77 <th>
  78                 <p>
  79                   With Local Functions (GCC only)
  80                 </p>
  81               </th>
  82 <th>
  83                 <p>
  84                   C++11 Lambdas
  85                 </p>
  86               </th>
  87 </tr></thead>
  88 <tbody><tr>
  89 <td>
  90                 <p>
  91 </p>
  92 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">int</span> <span class="identifier">val</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
  93 <span class="keyword">int</span> <span class="identifier">nums</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>
  94 <span class="keyword">int</span><span class="special">*</span> <span class="identifier">end</span> <span class="special">=</span> <span class="identifier">nums</span> <span class="special">+</span> <span class="number">3</span><span class="special">;</span>
  95
  96 <span class="keyword">int</span><span class="special">*</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">find_if</span><span class="special">(</span><span class="identifier">nums</span><span class="special">,</span> <span class="identifier">end</span><span class="special">,</span>
  97     <span class="identifier">GCC_LAMBDA</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bind</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">num</span><span class="special">,</span> <span class="keyword">return</span> <span class="keyword">bool</span><span class="special">)</span> <span class="special">{</span>
  98         <span class="keyword">return</span> <span class="identifier">num</span> <span class="special">==</span> <span class="identifier">val</span><span class="special">;</span>
  99     <span class="special">}</span> <span class="identifier">GCC_LAMBDA_END</span>
 100 <span class="special">);</span>
 101 </pre>
 102 <p>
 103                 </p>
 104               </td>
 105 <td>
 106                 <p>
 107 </p>
 108 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">int</span> <span class="identifier">val</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
 109 <span class="keyword">int</span> <span class="identifier">nums</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>
 110 <span class="keyword">int</span><span class="special">*</span> <span class="identifier">end</span> <span class="special">=</span> <span class="identifier">nums</span> <span class="special">+</span> <span class="number">3</span><span class="special">;</span>
 111
 112 <span class="keyword">int</span><span class="special">*</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">find_if</span><span class="special">(</span><span class="identifier">nums</span><span class="special">,</span> <span class="identifier">end</span><span class="special">,</span>
 113     <span class="special">[</span><span class="identifier">val</span><span class="special">](</span><span class="keyword">int</span> <span class="identifier">num</span><span class="special">)</span> <span class="special">-&gt;</span> <span class="keyword">bool</span> <span class="special">{</span>
 114         <span class="keyword">return</span> <span class="identifier">num</span> <span class="special">==</span> <span class="identifier">val</span><span class="special">;</span>
 115     <span class="special">}</span>
 116 <span class="special">);</span>
 117 </pre>
 118 <p>
 119                 </p>
 120               </td>
 121 </tr></tbody>
 122 </table></div>
 123 <p>
 124         The GCC lambda function macros are implemented using local functions (see
 125         also <a href="../../../example/gcc_lambda.hpp" target="_top"><code class="literal">gcc_lambda.hpp</code></a>):
 126       </p>
 127 <p>
 128 </p>
 129 <pre class="programlisting"><span class="preprocessor">#   define</span> <span class="identifier">GCC_LAMBDA_</span><span class="special">(</span><span class="identifier">binds</span><span class="special">,</span> <span class="identifier">params</span><span class="special">,</span> <span class="identifier">results</span><span class="special">)</span> <span class="special">\</span>
 130         <span class="special">({</span> <span class="comment">/* open statement expression (GCC extension only) */</span> <span class="special">\</span>
 131         <span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span> <span class="special">\</span>
 132             <span class="identifier">BOOST_PP_LIST_ENUM</span><span class="special">(</span><span class="identifier">BOOST_PP_LIST_APPEND</span><span class="special">(</span><span class="identifier">binds</span><span class="special">,</span> <span class="special">\</span>
 133                 <span class="identifier">BOOST_PP_LIST_APPEND</span><span class="special">(</span><span class="identifier">params</span><span class="special">,</span> <span class="special">\</span>
 134                     <span class="identifier">BOOST_PP_IIF</span><span class="special">(</span><span class="identifier">BOOST_PP_LIST_IS_NIL</span><span class="special">(</span><span class="identifier">results</span><span class="special">),</span> <span class="special">\</span>
 135                         <span class="special">(</span><span class="keyword">return</span> <span class="keyword">void</span><span class="special">,</span> <span class="identifier">BOOST_PP_NIL</span><span class="special">)</span> <span class="comment">/* default for lambdas */</span> <span class="special">\</span>
 136                     <span class="special">,</span> <span class="special">\</span>
 137                         <span class="identifier">results</span> <span class="special">\</span>
 138                     <span class="special">)\</span>
 139                 <span class="special">)</span> <span class="special">\</span>
 140             <span class="special">))</span> <span class="special">\</span>
 141         <span class="special">)</span>
 142 </pre>
 143 <p>
 144       </p>
 145 <p>
 146 </p>
 147 <pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">GCC_LAMBDA_END_</span><span class="special">(</span><span class="identifier">id</span><span class="special">)</span> <span class="special">\</span>
 148     <span class="identifier">BOOST_LOCAL_FUNCTION_NAME</span><span class="special">(</span><span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">gcc_lambda_</span><span class="special">,</span> <span class="identifier">id</span><span class="special">))</span> <span class="special">\</span>
 149     <span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">gcc_lambda_</span><span class="special">,</span> <span class="identifier">id</span><span class="special">);</span> <span class="special">\</span>
 150     <span class="special">})</span> <span class="comment">/* close statement expression (GCC extension only) */</span>
 151 </pre>
 152 <p>
 153       </p>
 154 <p>
 155         This is possible because GCC statement expressions allow to use declaration
 156         statements within expressions and therefore to declare a local function within
 157         an expression. The macros automatically detect if the compiler supports
 158         <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 159         lambda functions</a> in which case the implementation uses native lambdas
 160         instead of local functions in GCC statement expressions. However, <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 161         lambda functions</a> do not support constant binding so it is best to
 162         only use <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">bind</span>
 163         <span class="identifier">variable</span></code> (same as <code class="computeroutput"><span class="special">=</span><span class="identifier">variable</span></code>
 164         for <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 165         lambda functions</a>) and <code class="computeroutput"><span class="identifier">bind</span><span class="special">&amp;</span> <span class="identifier">variable</span></code>
 166         (same as <code class="computeroutput"><span class="special">&amp;</span><span class="identifier">variable</span></code>
 167         for <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 168         lambda functions</a>') because these have the exact same semantic between
 169         the local function and the native lambda implementations. Furthermore, local
 170         functions allow to bind data members directly while <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 171         lambda functions</a> require to access data members via binding the object
 172         <code class="computeroutput"><span class="keyword">this</span></code>. Unfortunately, the short-hand
 173         binds <code class="computeroutput"><span class="special">&amp;</span></code> and <code class="computeroutput"><span class="special">=</span></code> of <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 174         lambda functions</a> (which automatically bind all variables in scope
 175         either by reference or value) are not supported by these GCC lambda function
 176         macros because they are not supported by local functions. Finally, the result
 177         type <code class="computeroutput"><span class="keyword">return</span> </code><code class="literal"><span class="emphasis"><em>result-type</em></span></code>
 178         is optional and it is assumed <code class="computeroutput"><span class="keyword">void</span></code>
 179         when it is not specified (same as with <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 180         lambda functions</a>).
 181       </p>
 182 </div>
 183 <div class="section">
 184 <div class="titlepage"><div><div><h3 class="title">
 185 <a name="boost_localfunction.examples.constant_blocks"></a><a class="link" href="examples.html#boost_localfunction.examples.constant_blocks" title="Constant Blocks">Constant
 186       Blocks</a>
 187 </h3></div></div></div>
 188 <p>
 189         It is possible to use local functions to check assertions between variables
 190         that are made constant within the asserted expressions. This is advantageous
 191         because assertions are not supposed to change the state of the program and
 192         ideally the compiler will not compile assertions that modify variables.
 193       </p>
 194 <p>
 195         For example, consider the following assertion where by mistake we programmed
 196         <code class="computeroutput"><span class="keyword">operator</span><span class="special">=</span></code>
 197         instead of <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code>:
 198       </p>
 199 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
 200 <span class="identifier">assert</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">// Mistakenly `=` instead of `==`.</span>
 201 </pre>
 202 <p>
 203         Ideally this code will not compile instead this example not only compiles
 204         but the assertion even passes the run-time check and no error is generated
 205         at all. The <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2004/n1613.pdf" target="_top">[N1613]</a>
 206         paper introduces the concept of a <span class="emphasis"><em>const-block</em></span> which
 207         could be used to wrap the assertion above and catch the programming error
 208         at compile-time. Similarly, the following code will generate a compile-time
 209         error when <code class="computeroutput"><span class="keyword">operator</span><span class="special">=</span></code>
 210         is mistakenly used instead of <code class="computeroutput"><span class="keyword">operator</span><span class="special">==</span></code> because both <code class="computeroutput"><span class="identifier">x</span></code>
 211         and <code class="computeroutput"><span class="identifier">y</span></code> are made constants
 212         (using local functions) within the block of code performing the assertion
 213         (see also <a href="../../../example/const_block_error.cpp" target="_top"><code class="literal">const_block_error.cpp</code></a>):
 214       </p>
 215 <div class="informaltable"><table class="table">
 216 <colgroup>
 217 <col>
 218 <col>
 219 </colgroup>
 220 <thead><tr>
 221 <th>
 222                 <p>
 223                   With Local Functions
 224                 </p>
 225               </th>
 226 <th>
 227                 <p>
 228                   N1613 Const-Blocks
 229                 </p>
 230               </th>
 231 </tr></thead>
 232 <tbody><tr>
 233 <td>
 234                 <p>
 235 </p>
 236 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
 237 <span class="identifier">CONST_BLOCK</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">// Constant block.</span>
 238     <span class="identifier">assert</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">// Compiler error.</span>
 239 <span class="special">}</span> <span class="identifier">CONST_BLOCK_END</span>
 240 </pre>
 241 <p>
 242                 </p>
 243               </td>
 244 <td>
 245                 <p>
 246 </p>
 247 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
 248 <span class="keyword">const</span> <span class="special">{</span>             <span class="comment">// Constant block.</span>
 249     <span class="identifier">assert</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">// Compiler error.</span>
 250 <span class="special">}</span>
 251 </pre>
 252 <p>
 253                 </p>
 254               </td>
 255 </tr></tbody>
 256 </table></div>
 257 <p>
 258         The constant block macros are implemented using local functions (see also
 259         <a href="../../../example/const_block.hpp" target="_top"><code class="literal">const_block.hpp</code></a>):
 260       </p>
 261 <p>
 262 </p>
 263 <pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">CONST_BLOCK_</span><span class="special">(</span><span class="identifier">variables</span><span class="special">)</span> <span class="special">\</span>
 264     <span class="keyword">void</span> <span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span> <span class="special">\</span>
 265         <span class="identifier">BOOST_PP_IIF</span><span class="special">(</span><span class="identifier">BOOST_PP_LIST_IS_NIL</span><span class="special">(</span><span class="identifier">variables</span><span class="special">),</span> <span class="special">\</span>
 266             <span class="keyword">void</span> <span class="identifier">BOOST_PP_TUPLE_EAT</span><span class="special">(</span><span class="number">3</span><span class="special">)</span> <span class="special">\</span>
 267         <span class="special">,</span> <span class="special">\</span>
 268             <span class="identifier">BOOST_PP_LIST_FOR_EACH_I</span> <span class="special">\</span>
 269         <span class="special">)(</span><span class="identifier">CONST_BLOCK_BIND_</span><span class="special">,</span> <span class="special">~,</span> <span class="identifier">variables</span><span class="special">)</span> <span class="special">\</span>
 270     <span class="special">)</span>
 271 </pre>
 272 <p>
 273       </p>
 274 <p>
 275 </p>
 276 <pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">CONST_BLOCK_END_</span><span class="special">(</span><span class="identifier">id</span><span class="special">)</span> <span class="special">\</span>
 277     <span class="identifier">BOOST_LOCAL_FUNCTION_NAME</span><span class="special">(</span><span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">const_block_</span><span class="special">,</span> <span class="identifier">id</span><span class="special">))</span> <span class="special">\</span>
 278     <span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">const_block_</span><span class="special">,</span> <span class="identifier">id</span><span class="special">)();</span> <span class="comment">/* call local function immediately */</span>
 279 </pre>
 280 <p>
 281       </p>
 282 <p>
 283         The constant block macros are implemented using a local function which binds
 284         by constant reference <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">bind</span><span class="special">&amp;</span></code>
 285         all the specified variables (so the variables are constant within the code
 286         block but they do not need to be <code class="computeroutput"><span class="identifier">CopyConstructible</span></code>
 287         and no extra copy is performed). The local function executes the <code class="computeroutput"><span class="identifier">assert</span></code> instruction in its body and it is
 288         called immediately after it is defined. More in general, constant blocks
 289         can be used to evaluate any instruction (not just assertions) within a block
 290         were all specified variables are constant.
 291       </p>
 292 <p>
 293         Unfortunately, constant blocks cannot be implemented with <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 294         lambda functions</a> because these do not support constant binding. Variables
 295         bound by value using <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 296         lambda functions</a> (<code class="computeroutput"><span class="identifier">variable</span></code>,
 297         <code class="computeroutput"><span class="special">=</span><span class="identifier">variable</span></code>,
 298         and <code class="computeroutput"><span class="special">=</span></code>) are constant but they
 299         are required to be <code class="computeroutput"><span class="identifier">CopyConstructible</span></code>
 300         and they introduce potentially expensive copy operations. <a href="#ftn.boost_localfunction.examples.constant_blocks.f0" class="footnote" name="boost_localfunction.examples.constant_blocks.f0"><sup class="footnote">[29]</sup></a> Of course it is always possible to introduce extra constant variables
 301         and bind these variables to the <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 302         lambda functions</a> but the constant block code will then have to manage
 303         the declaration and initialization of these extra variables plus it will
 304         have to use the extra variable names instead of the original variable names:
 305       </p>
 306 <p>
 307 </p>
 308 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">y</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
 309 <span class="keyword">const</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">x</span><span class="special">)&amp;</span> <span class="identifier">const_x</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">;</span> <span class="comment">// Constant so cannot be modified</span>
 310 <span class="keyword">const</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">y</span><span class="special">)&amp;</span> <span class="identifier">const_y</span> <span class="special">=</span> <span class="identifier">y</span><span class="special">;</span> <span class="comment">// and reference so no copy.</span>
 311 <span class="special">[&amp;</span><span class="identifier">const_x</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">const_y</span><span class="special">]()</span> <span class="special">{</span>        <span class="comment">// Lambda functions (C++11 only).</span>
 312     <span class="identifier">assert</span><span class="special">(</span><span class="identifier">const_x</span> <span class="special">=</span> <span class="identifier">const_y</span><span class="special">);</span>  <span class="comment">// Unfortunately, `const_` names.</span>
 313 <span class="special">}();</span>
 314 </pre>
 315 <p>
 316       </p>
 317 <p>
 318         In many cases the use of an extra constant variable <code class="computeroutput"><span class="identifier">const_x</span></code>
 319         can be acceptable but in other cases it might be preferable to maintain the
 320         same variable name <code class="computeroutput"><span class="identifier">x</span></code> within
 321         the function body.
 322       </p>
 323 </div>
 324 <div class="section">
 325 <div class="titlepage"><div><div><h3 class="title">
 326 <a name="boost_localfunction.examples.scope_exits"></a><a class="link" href="examples.html#boost_localfunction.examples.scope_exits" title="Scope Exits">Scope Exits</a>
 327 </h3></div></div></div>
 328 <p>
 329         Scope exits allow to execute arbitrary code at the exit of the enclosing
 330         scope and they are provided by the <a href="http://www.boost.org/libs/scope_exit" target="_top">Boost.ScopeExit</a>
 331         library.
 332       </p>
 333 <p>
 334         For curiosity, here we show how to re-implement scope exits using local functions.
 335         One small advantage of scope exits that use local functions is that they
 336         support constant binding. <a href="http://www.boost.org/libs/scope_exit" target="_top">Boost.ScopeExit</a>
 337         does not directly support constant binding (however, it is always possible
 338         to introduce an extra <code class="computeroutput"><span class="keyword">const</span></code>
 339         local variable, assign it to the value to bind, and then bind the <code class="computeroutput"><span class="keyword">const</span></code> variable so to effectively have constant
 340         binding with <a href="http://www.boost.org/libs/scope_exit" target="_top">Boost.ScopeExit</a>
 341         as well).
 342       </p>
 343 <div class="note"><table border="0" summary="Note">
 344 <tr>
 345 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
 346 <th align="left">Note</th>
 347 </tr>
 348 <tr><td align="left" valign="top"><p>
 349           In general, the authors recommend to use <a href="http://www.boost.org/libs/scope_exit" target="_top">Boost.ScopeExit</a>
 350           instead of the code listed by this example whenever possible (because
 351           <a href="http://www.boost.org/libs/scope_exit" target="_top">Boost.ScopeExit</a>
 352           is a library deliberately designed to support the scope exit construct).
 353         </p></td></tr>
 354 </table></div>
 355 <p>
 356         The following example binds <code class="computeroutput"><span class="identifier">p</span></code>
 357         by constant reference so this variable cannot be modified within the scope
 358         exit body but it is not copied and it will present the value it has at the
 359         exit of the enclosing scope and not at the scope exit declaration (see also
 360         <a href="../../../example/scope_exit.cpp" target="_top"><code class="literal">scope_exit.cpp</code></a>):
 361       </p>
 362 <div class="informaltable"><table class="table">
 363 <colgroup>
 364 <col>
 365 <col>
 366 </colgroup>
 367 <thead><tr>
 368 <th>
 369                 <p>
 370                   With Local Functions
 371                 </p>
 372               </th>
 373 <th>
 374                 <p>
 375                   Boost.ScopeExit
 376                 </p>
 377               </th>
 378 </tr></thead>
 379 <tbody><tr>
 380 <td>
 381                 <p>
 382 </p>
 383 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">person</span><span class="special">&amp;</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">persons_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span>
 384 <span class="identifier">person</span><span class="special">::</span><span class="identifier">evolution_t</span> <span class="identifier">checkpoint</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">evolution_</span><span class="special">;</span>
 385
 386 <span class="identifier">SCOPE_EXIT</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">bind</span> <span class="identifier">checkpoint</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">bind</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">bind</span> <span class="identifier">this_</span><span class="special">)</span> <span class="special">{</span>
 387     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">checkpoint</span> <span class="special">==</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">evolution_</span><span class="special">)</span> <span class="identifier">this_</span><span class="special">-&gt;</span><span class="identifier">persons_</span><span class="special">.</span><span class="identifier">pop_back</span><span class="special">();</span>
 388 <span class="special">}</span> <span class="identifier">SCOPE_EXIT_END</span>
 389 </pre>
 390 <p>
 391                 </p>
 392               </td>
 393 <td>
 394                 <p>
 395 </p>
 396 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">person</span><span class="special">&amp;</span> <span class="identifier">p</span> <span class="special">=</span> <span class="identifier">persons_</span><span class="special">.</span><span class="identifier">back</span><span class="special">();</span>
 397 <span class="identifier">person</span><span class="special">::</span><span class="identifier">evolution_t</span> <span class="identifier">checkpoint</span> <span class="special">=</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">evolution_</span><span class="special">;</span>
 398
 399 <span class="identifier">BOOST_SCOPE_EXIT</span><span class="special">(</span><span class="identifier">checkpoint</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">p</span><span class="special">,</span> <span class="identifier">this_</span><span class="special">)</span> <span class="special">{</span> <span class="comment">// Or extra variable `const_p`.</span>
 400     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">checkpoint</span> <span class="special">==</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">evolution_</span><span class="special">)</span> <span class="identifier">this_</span><span class="special">-&gt;</span><span class="identifier">persons_</span><span class="special">.</span><span class="identifier">pop_back</span><span class="special">();</span>
 401 <span class="special">}</span> <span class="identifier">BOOST_SCOPE_EXIT_END</span>
 402 </pre>
 403 <p>
 404                 </p>
 405               </td>
 406 </tr></tbody>
 407 </table></div>
 408 <p>
 409         The scope exit macros are implemented by passing a local function when constructing
 410         an object of the following class (see also <a href="../../../example/scope_exit.hpp" target="_top"><code class="literal">scope_exit.hpp</code></a>):
 411       </p>
 412 <p>
 413 </p>
 414 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">scope_exit</span> <span class="special">{</span>
 415     <span class="identifier">scope_exit</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="keyword">void</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;</span> <span class="identifier">f</span><span class="special">):</span> <span class="identifier">f_</span><span class="special">(</span><span class="identifier">f</span><span class="special">)</span> <span class="special">{}</span>
 416     <span class="special">~</span><span class="identifier">scope_exit</span><span class="special">(</span><span class="keyword">void</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f_</span><span class="special">();</span> <span class="special">}</span>
 417 <span class="keyword">private</span><span class="special">:</span>
 418     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="keyword">void</span> <span class="special">(</span><span class="keyword">void</span><span class="special">)&gt;</span> <span class="identifier">f_</span><span class="special">;</span>
 419 <span class="special">};</span>
 420 </pre>
 421 <p>
 422       </p>
 423 <p>
 424 </p>
 425 <pre class="programlisting"><span class="preprocessor">#   define</span> <span class="identifier">SCOPE_EXIT</span><span class="special">(...)</span> <span class="special">\</span>
 426         <span class="keyword">void</span> <span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="identifier">__VA_ARGS__</span><span class="special">)</span>
 427 </pre>
 428 <p>
 429       </p>
 430 <p>
 431 </p>
 432 <pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">SCOPE_EXIT_END_</span><span class="special">(</span><span class="identifier">id</span><span class="special">)</span> <span class="special">\</span>
 433     <span class="identifier">BOOST_LOCAL_FUNCTION_NAME</span><span class="special">(</span><span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">scope_exit_func_</span><span class="special">,</span> <span class="identifier">id</span><span class="special">))</span> <span class="special">\</span>
 434     <span class="identifier">scope_exit</span> <span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">scope_exit_</span><span class="special">,</span> <span class="identifier">id</span><span class="special">)(</span> <span class="special">\</span>
 435             <span class="identifier">BOOST_PP_CAT</span><span class="special">(</span><span class="identifier">scope_exit_func_</span><span class="special">,</span> <span class="identifier">id</span><span class="special">));</span>
 436 </pre>
 437 <p>
 438       </p>
 439 <p>
 440         A local variable within the enclosing scope is used to hold the object so
 441         the destructor will be invoked at the exit of the enclosing scope and it
 442         will in turn call the local function executing the scope exit instructions.
 443         The scope exit local function has no parameter and <code class="computeroutput"><span class="keyword">void</span></code>
 444         result type but it supports binding and constant binding.
 445       </p>
 446 </div>
 447 <div class="section">
 448 <div class="titlepage"><div><div><h3 class="title">
 449 <a name="boost_localfunction.examples.boost_phoenix_functions"></a><a class="link" href="examples.html#boost_localfunction.examples.boost_phoenix_functions" title="Boost.Phoenix Functions">Boost.Phoenix
 450       Functions</a>
 451 </h3></div></div></div>
 452 <p>
 453         Local functions can be used to create <a href="http://www.boost.org/libs/phoenix" target="_top">Boost.Phoenix</a>
 454         functions. For example (see also <a href="../../../example/phoenix_factorial_local.cpp" target="_top"><code class="literal">phoenix_factorial_local.cpp</code></a>
 455         and <a href="../../../example/phoenix_factorial.cpp" target="_top"><code class="literal">phoenix_factorial.cpp</code></a>):
 456       </p>
 457 <div class="informaltable"><table class="table">
 458 <colgroup>
 459 <col>
 460 <col>
 461 </colgroup>
 462 <thead><tr>
 463 <th>
 464                 <p>
 465                   Local Functions
 466                 </p>
 467               </th>
 468 <th>
 469                 <p>
 470                   Global Functor
 471                 </p>
 472               </th>
 473 </tr></thead>
 474 <tbody><tr>
 475 <td>
 476                 <p>
 477 </p>
 478 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><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>
 479     <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg1</span><span class="special">;</span>
 480
 481     <span class="keyword">int</span> <span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> <span class="comment">// Unfortunately, monomorphic.</span>
 482         <span class="keyword">return</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="number">1</span> <span class="special">:</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">factorial_impl</span><span class="special">(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
 483     <span class="special">}</span> <span class="identifier">BOOST_LOCAL_FUNCTION_NAME</span><span class="special">(</span><span class="identifier">recursive</span> <span class="identifier">factorial_impl</span><span class="special">)</span>
 484
 485     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="special">(</span><span class="keyword">int</span><span class="special">)&gt;</span> <span class="special">&gt;</span>
 486             <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">factorial_impl</span><span class="special">);</span> <span class="comment">// Phoenix function from local function.</span>
 487
 488     <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">4</span><span class="special">;</span>
 489     <span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">factorial</span><span class="special">(</span><span class="identifier">i</span><span class="special">)()</span> <span class="special">==</span> <span class="number">24</span><span class="special">);</span>      <span class="comment">// Call.</span>
 490     <span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">factorial</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">)</span> <span class="special">==</span> <span class="number">24</span><span class="special">);</span>  <span class="comment">// Lazy call.</span>
 491     <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
 492 <span class="special">}</span>
 493 </pre>
 494 <p>
 495                 </p>
 496               </td>
 497 <td>
 498                 <p>
 499 </p>
 500 <pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">struct</span> <span class="identifier">factorial_impl</span> <span class="special">{</span> <span class="comment">// Phoenix function from global functor.</span>
 501     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Sig</span><span class="special">&gt;</span>
 502     <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">;</span>
 503
 504     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">This</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Arg</span><span class="special">&gt;</span>
 505     <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">This</span> <span class="special">(</span><span class="identifier">Arg</span><span class="special">)&gt;</span> <span class="special">:</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">This</span> <span class="special">(</span><span class="identifier">Arg</span> <span class="keyword">const</span><span class="special">&amp;)&gt;</span> <span class="special">{};</span>
 506
 507     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">This</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Arg</span><span class="special">&gt;</span>
 508     <span class="keyword">struct</span> <span class="identifier">result</span><span class="special">&lt;</span><span class="identifier">This</span> <span class="special">(</span><span class="identifier">Arg</span><span class="special">&amp;)&gt;</span> <span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">Arg</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>
 509
 510     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Arg</span><span class="special">&gt;</span> <span class="comment">// Polymorphic.</span>
 511     <span class="identifier">Arg</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Arg</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span>
 512         <span class="keyword">return</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="number">1</span> <span class="special">:</span> <span class="identifier">n</span> <span class="special">*</span> <span class="special">(*</span><span class="keyword">this</span><span class="special">)(</span><span class="identifier">n</span> <span class="special">-</span> <span class="number">1</span><span class="special">);</span>
 513     <span class="special">}</span>
 514 <span class="special">};</span>
 515
 516 <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>
 517     <span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">arg_names</span><span class="special">::</span><span class="identifier">arg1</span><span class="special">;</span>
 518
 519     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">function</span><span class="special">&lt;</span><span class="identifier">factorial_impl</span><span class="special">&gt;</span> <span class="identifier">factorial</span><span class="special">;</span>
 520
 521     <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">4</span><span class="special">;</span>
 522     <span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">factorial</span><span class="special">(</span><span class="identifier">i</span><span class="special">)()</span> <span class="special">==</span> <span class="number">24</span><span class="special">);</span>      <span class="comment">// Call.</span>
 523     <span class="identifier">BOOST_TEST</span><span class="special">(</span><span class="identifier">factorial</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">)</span> <span class="special">==</span> <span class="number">24</span><span class="special">);</span>  <span class="comment">// Lazy call.</span>
 524     <span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">report_errors</span><span class="special">();</span>
 525 <span class="special">}</span>
 526 </pre>
 527 <p>
 528                 </p>
 529               </td>
 530 </tr></tbody>
 531 </table></div>
 532 <p>
 533         This is presented here mainly as a curiosity because <a href="http://www.boost.org/libs/phoenix" target="_top">Boost.Phoenix</a>
 534         functions created from local functions have the important limitation that
 535         they cannot be polymorphic. <a href="#ftn.boost_localfunction.examples.boost_phoenix_functions.f0" class="footnote" name="boost_localfunction.examples.boost_phoenix_functions.f0"><sup class="footnote">[30]</sup></a> Therefore, in many cases creating the <a href="http://www.boost.org/libs/phoenix" target="_top">Boost.Phoenix</a>
 536         function from global functors (possibly with the help of <a href="http://www.boost.org/libs/phoenix" target="_top">Boost.Phoenix</a>
 537         adaptor macros) might be a more useful.
 538       </p>
 539 </div>
 540 <div class="section">
 541 <div class="titlepage"><div><div><h3 class="title">
 542 <a name="boost_localfunction.examples.closures"></a><a class="link" href="examples.html#boost_localfunction.examples.closures" title="Closures">Closures</a>
 543 </h3></div></div></div>
 544 <p>
 545         The following are examples of <a href="http://en.wikipedia.org/wiki/Closure_(computer_science)" target="_top">closures</a>
 546         that illustrate how to return local functions to the calling scope (note
 547         how extra care is taken in order to ensure that all bound variables remain
 548         valid at the calling scope):
 549       </p>
 550 <div class="informaltable"><table class="table">
 551 <colgroup><col></colgroup>
 552 <thead><tr><th>
 553                 <p>
 554                   Files
 555                 </p>
 556               </th></tr></thead>
 557 <tbody>
 558 <tr><td>
 559                 <p>
 560                   <a href="../../../test/return_inc.cpp" target="_top"><code class="literal">return_inc.cpp</code></a>
 561                 </p>
 562               </td></tr>
 563 <tr><td>
 564                 <p>
 565                   <a href="../../../test/return_this.cpp" target="_top"><code class="literal">return_this.cpp</code></a>
 566                 </p>
 567               </td></tr>
 568 <tr><td>
 569                 <p>
 570                   <a href="../../../test/return_setget.cpp" target="_top"><code class="literal">return_setget.cpp</code></a>
 571                 </p>
 572               </td></tr>
 573 <tr><td>
 574                 <p>
 575                   <a href="../../../test/return_derivative.cpp" target="_top"><code class="literal">return_derivative.cpp</code></a>
 576                 </p>
 577               </td></tr>
 578 </tbody>
 579 </table></div>
 580 </div>
 581 <div class="section">
 582 <div class="titlepage"><div><div><h3 class="title">
 583 <a name="boost_localfunction.examples.gcc_nested_functions"></a><a class="link" href="examples.html#boost_localfunction.examples.gcc_nested_functions" title="GCC Nested Functions">GCC
 584       Nested Functions</a>
 585 </h3></div></div></div>
 586 <p>
 587         The GCC C compiler supports local functions as a non-standard extension under
 588         the name of <a href="http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html" target="_top">nested
 589         functions</a>. Note that nested functions are exclusively a C extension
 590         of the GCC compiler (they are not supported for C++ not even by the GCC compiler,
 591         and they are not part of any C or C++ standard, nor they are supported by
 592         other compilers like MSVC).
 593       </p>
 594 <p>
 595         The following examples are taken form the GCC nested function documentation
 596         and programmed using local functions:
 597       </p>
 598 <div class="informaltable"><table class="table">
 599 <colgroup><col></colgroup>
 600 <thead><tr><th>
 601                 <p>
 602                   Files
 603                 </p>
 604               </th></tr></thead>
 605 <tbody>
 606 <tr><td>
 607                 <p>
 608                   <a href="../../../example/gcc_square.cpp" target="_top"><code class="literal">gcc_square.cpp</code></a>
 609                 </p>
 610               </td></tr>
 611 <tr><td>
 612                 <p>
 613                   <a href="../../../example/gcc_access.cpp" target="_top"><code class="literal">gcc_access.cpp</code></a>
 614                 </p>
 615               </td></tr>
 616 <tr><td>
 617                 <p>
 618                   <a href="../../../example/gcc_store.cpp" target="_top"><code class="literal">gcc_store.cpp</code></a>
 619                 </p>
 620               </td></tr>
 621 </tbody>
 622 </table></div>
 623 </div>
 624 <div class="section">
 625 <div class="titlepage"><div><div><h3 class="title">
 626 <a name="boost_localfunction.examples.n_papers"></a><a class="link" href="examples.html#boost_localfunction.examples.n_papers" title="N-Papers">N-Papers</a>
 627 </h3></div></div></div>
 628 <p>
 629         The following examples are taken from different C++ "N-papers"
 630         and programmed using local functions:
 631       </p>
 632 <div class="informaltable"><table class="table">
 633 <colgroup>
 634 <col>
 635 <col>
 636 </colgroup>
 637 <thead><tr>
 638 <th>
 639                 <p>
 640                   Files
 641                 </p>
 642               </th>
 643 <th>
 644                 <p>
 645                   Notes
 646                 </p>
 647               </th>
 648 </tr></thead>
 649 <tbody>
 650 <tr>
 651 <td>
 652                 <p>
 653                   <a href="../../../example/n2550_find_if.cpp" target="_top"><code class="literal">n2550_find_if.cpp</code></a>
 654                 </p>
 655               </td>
 656 <td>
 657                 <p>
 658                   This example is adapted from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2550.pdf" target="_top">[N2550]</a>
 659                   (<a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 660                   lambda functions</a>): It passes a local function to the STL
 661                   algorithm <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">find_if</span></code>.
 662                 </p>
 663               </td>
 664 </tr>
 665 <tr>
 666 <td>
 667                 <p>
 668                   <a href="../../../example/n2529_this.cpp" target="_top"><code class="literal">n2529_this.cpp</code></a>
 669                 </p>
 670               </td>
 671 <td>
 672                 <p>
 673                   This example is adapted from <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2529.pdf" target="_top">[N2529]</a>
 674                   (<a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 675                   lambda functions</a>): It binds the object in scope <code class="computeroutput"><span class="keyword">this</span></code> to a local function.
 676                 </p>
 677               </td>
 678 </tr>
 679 </tbody>
 680 </table></div>
 681 </div>
 682 <div class="footnotes">
 683 <br><hr style="width:100; text-align:left;margin-left: 0">
 684 <div id="ftn.boost_localfunction.examples.constant_blocks.f0" class="footnote"><p><a href="#boost_localfunction.examples.constant_blocks.f0" class="para"><sup class="para">[29] </sup></a>
 685           Ideally, <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions" target="_top">C++11
 686           lambda functions</a> would allow to bind variables also using <code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">variable</span></code> (constant reference) and <code class="computeroutput"><span class="keyword">const</span><span class="special">&amp;</span></code>
 687           (all variables by constant reference).
 688         </p></div>
 689 <div id="ftn.boost_localfunction.examples.boost_phoenix_functions.f0" class="footnote"><p><a href="#boost_localfunction.examples.boost_phoenix_functions.f0" class="para"><sup class="para">[30] </sup></a>
 690           <span class="bold"><strong>Rationale.</strong></span> Local functions can only be
 691           monomorphic because they are implemented using local classes and local
 692           classes cannot be templates in C++ (not even in <a href="http://www.open-std.org/JTC1/SC22/WG21/" target="_top">C++11</a>).
 693         </p></div>
 694 </div>
 695 </div>
 696 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 697 <td align="left"></td>
 698 <td align="right"><div class="copyright-footer">Copyright &#169; 2009-2012 Lorenzo
 699       Caminiti<p>
 700         Distributed under the Boost Software License, Version 1.0 (see accompanying
 701         file LICENSE_1_0.txt or a copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
 702       </p>
 703 </div></td>
 704 </tr></table>
 705 <hr>
 706 <div class="spirit-nav">
 707 <a accesskey="p" href="advanced_topics.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="alternatives.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
 708 </div>
 709 </body>
 710 </html>