libs/bind/doc/html/bind.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Chapter&#160;1.&#160;Boost.Bind</title>
   5 <link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
   7 <link rel="home" href="bind.html" title="Chapter&#160;1.&#160;Boost.Bind">
   8 </head>
   9 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  10 <table cellpadding="2" width="100%"><tr>
  11 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
  12 <td align="center"><a href="../../../../index.html">Home</a></td>
  13 <td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
  14 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  15 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  16 <td align="center"><a href="../../../../more/index.htm">More</a></td>
  17 </tr></table>
  18 <hr>
  19 <div class="spirit-nav"></div>
  20 <div class="chapter">
  21 <div class="titlepage"><div>
  22 <div><h2 class="title">
  23 <a name="bind"></a>Chapter&#160;1.&#160;Boost.Bind</h2></div>
  24 <div><p class="copyright">Copyright &#169; 2001, 2002 Peter Dimov and Multi Media Ltd.</p></div>
  25 <div><p class="copyright">Copyright &#169; 2003-2008 Peter Dimov</p></div>
  26 <div><div class="legalnotice">
  27 <a name="bind.legal"></a><p>
  28         Distributed under the <a href="http://boost.org/LICENSE_1_0.txt" target="_top">Boost
  29         Software License, Version 1.0</a>.
  30       </p>
  31 </div></div>
  32 </div></div>
  33 <div class="toc">
  34 <p><b>Table of Contents</b></p>
  35 <dl class="toc">
  36 <dt><span class="section"><a href="bind.html#bind.purpose">Purpose</a></span></dt>
  37 <dd><dl>
  38 <dt><span class="section"><a href="bind.html#bind.purpose.using_bind_with_functions_and_fu">Using
  39       bind with functions and function pointers</a></span></dt>
  40 <dt><span class="section"><a href="bind.html#bind.purpose.with_function_objects">Using bind with function
  41       objects</a></span></dt>
  42 <dt><span class="section"><a href="bind.html#bind.purpose.using_bind_with_pointers_to_memb">Using
  43       bind with pointers to members</a></span></dt>
  44 <dt><span class="section"><a href="bind.html#bind.purpose.using_nested_binds_for_function_">Using
  45       nested binds for function composition</a></span></dt>
  46 <dt><span class="section"><a href="bind.html#bind.purpose.overloaded_operators_new_in_boos">Overloaded
  47       operators (new in Boost 1.33)</a></span></dt>
  48 </dl></dd>
  49 <dt><span class="section"><a href="bind.html#bind.examples">Examples</a></span></dt>
  50 <dd><dl>
  51 <dt><span class="section"><a href="bind.html#bind.examples.using_bind_with_standard_algorit">Using
  52       bind with standard algorithms</a></span></dt>
  53 <dt><span class="section"><a href="bind.html#bind.examples.using_bind_with_boost_function">Using bind
  54       with Boost.Function</a></span></dt>
  55 </dl></dd>
  56 <dt><span class="section"><a href="bind.html#bind.limitations">Limitations</a></span></dt>
  57 <dt><span class="section"><a href="bind.html#bind.faq">Frequently Asked Questions</a></span></dt>
  58 <dd><dl>
  59 <dt><span class="section"><a href="bind.html#bind.faq.why_doesn_t_this_compile">Why doesn't this compile?</a></span></dt>
  60 <dt><span class="section"><a href="bind.html#bind.faq.why_does_this_compile_it_should_">Why does this
  61       compile? It should not.</a></span></dt>
  62 <dt><span class="section"><a href="bind.html#bind.faq.Q_forms">What is the difference between <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code> and
  63       <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>?</a></span></dt>
  64 <dt><span class="section"><a href="bind.html#bind.faq.does_bind_work_with_windows_api_">Does bind
  65       work with Windows API functions?</a></span></dt>
  66 <dt><span class="section"><a href="bind.html#bind.faq.does_bind_work_with_com_methods">Does bind work
  67       with COM methods?</a></span></dt>
  68 <dt><span class="section"><a href="bind.html#bind.faq.does_bind_work_with_mac_toolbox_">Does bind
  69       work with Mac toolbox functions?</a></span></dt>
  70 <dt><span class="section"><a href="bind.html#bind.faq.does_bind_work_with_extern_c_fun">Does bind
  71       work with extern "C" functions?</a></span></dt>
  72 <dt><span class="section"><a href="bind.html#bind.faq.why_doesn_t_bind_automatically_r">Why doesn't
  73       bind automatically recognize nonstandard functions?</a></span></dt>
  74 </dl></dd>
  75 <dt><span class="section"><a href="bind.html#bind.troubleshooting">Troubleshooting</a></span></dt>
  76 <dd><dl>
  77 <dt><span class="section"><a href="bind.html#bind.troubleshooting.incorrect_number_of_arguments">Incorrect
  78       number of arguments</a></span></dt>
  79 <dt><span class="section"><a href="bind.html#bind.troubleshooting.the_function_object_cannot_be_ca">The
  80       function object cannot be called with the specified arguments</a></span></dt>
  81 <dt><span class="section"><a href="bind.html#bind.troubleshooting.accessing_an_argument_that_does_">Accessing
  82       an argument that does not exist</a></span></dt>
  83 <dt><span class="section"><a href="bind.html#bind.troubleshooting.inappropriate_use_of_bind_f">Inappropriate
  84       use of <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code></a></span></dt>
  85 <dt><span class="section"><a href="bind.html#bind.troubleshooting.inappropriate_use_of_bind_r_f">Inappropriate
  86       use of <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code></a></span></dt>
  87 <dt><span class="section"><a href="bind.html#bind.troubleshooting.binding_a_nonstandard_function">Binding
  88       a nonstandard function</a></span></dt>
  89 <dt><span class="section"><a href="bind.html#bind.troubleshooting.binding_an_overloaded_function">Binding
  90       an overloaded function</a></span></dt>
  91 <dt><span class="section"><a href="bind.html#bind.troubleshooting.modeling_stl_function_object_con">Modeling
  92       STL function object concepts</a></span></dt>
  93 <dt><span class="section"><a href="bind.html#bind.troubleshooting.const_in_signatures"><code class="computeroutput"><span class="keyword">const</span></code> in signatures</a></span></dt>
  94 <dt><span class="section"><a href="bind.html#bind.troubleshooting.msvc_specific_using_boost_bind">MSVC
  95       specific: <code class="computeroutput"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">;</span></code></a></span></dt>
  96 <dt><span class="section"><a href="bind.html#bind.troubleshooting.msvc_specific_class_templates_sh">MSVC
  97       specific: class templates shadow function templates</a></span></dt>
  98 <dt><span class="section"><a href="bind.html#bind.troubleshooting.msvc_specific_in_signatures_trea">MSVC
  99       specific: <code class="computeroutput"><span class="special">...</span></code> in signatures treated
 100       as type</a></span></dt>
 101 </dl></dd>
 102 <dt><span class="section"><a href="bind.html#bind.interface">Interface</a></span></dt>
 103 <dd><dl>
 104 <dt><span class="section"><a href="bind.html#bind.interface.synopsys">Synopsis</a></span></dt>
 105 <dt><span class="section"><a href="bind.html#bind.interface.common_requirements">Common requirements</a></span></dt>
 106 <dt><span class="section"><a href="bind.html#bind.interface.common_definitions">Common definitions</a></span></dt>
 107 <dt><span class="section"><a href="bind.html#bind.interface.bind"><code class="computeroutput"><span class="identifier">bind</span></code></a></span></dt>
 108 <dt><span class="section"><a href="bind.html#bind.interface.additional_overloads">Additional overloads</a></span></dt>
 109 </dl></dd>
 110 <dt><span class="section"><a href="bind.html#bind.implementation">Implementation</a></span></dt>
 111 <dd><dl>
 112 <dt><span class="section"><a href="bind.html#bind.implementation.files">Files</a></span></dt>
 113 <dt><span class="section"><a href="bind.html#bind.implementation.dependencies">Dependencies</a></span></dt>
 114 <dt><span class="section"><a href="bind.html#bind.implementation.number_of_arguments">Number of Arguments</a></span></dt>
 115 <dt><span class="section"><a href="bind.html#bind.implementation.stdcall"><code class="computeroutput"><span class="identifier">__stdcall</span></code>,
 116       <code class="computeroutput"><span class="identifier">__cdecl</span></code>, <code class="computeroutput"><span class="identifier">__fastcall</span></code>,
 117       and <code class="computeroutput"><span class="identifier">pascal</span></code> Support</a></span></dt>
 118 <dt><span class="section"><a href="bind.html#bind.implementation.visit_each_support"><code class="computeroutput"><span class="identifier">visit_each</span></code> support</a></span></dt>
 119 </dl></dd>
 120 <dt><span class="section"><a href="bind.html#bind.acknowledgements">Acknowledgements</a></span></dt>
 121 </dl>
 122 </div>
 123 <div class="section">
 124 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 125 <a name="bind.purpose"></a><a class="link" href="bind.html#bind.purpose" title="Purpose">Purpose</a>
 126 </h2></div></div></div>
 127 <p>
 128       <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span></code> is a generalization of the standard
 129       functions <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind1st</span></code> and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind2nd</span></code>.
 130       It supports arbitrary function objects, functions, function pointers, and member
 131       function pointers, and is able to bind any argument to a specific value or
 132       route input arguments into arbitrary positions. <code class="computeroutput"><span class="identifier">bind</span></code>
 133       does not place any requirements on the function object; in particular, it does
 134       not need the <code class="computeroutput"><span class="identifier">result_type</span></code>,
 135       <code class="computeroutput"><span class="identifier">first_argument_type</span></code> and <code class="computeroutput"><span class="identifier">second_argument_type</span></code> standard typedefs.
 136     </p>
 137 <div class="section">
 138 <div class="titlepage"><div><div><h3 class="title">
 139 <a name="bind.purpose.using_bind_with_functions_and_fu"></a><a class="link" href="bind.html#bind.purpose.using_bind_with_functions_and_fu" title="Using bind with functions and function pointers">Using
 140       bind with functions and function pointers</a>
 141 </h3></div></div></div>
 142 <p>
 143         Given these definitions:
 144       </p>
 145 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</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>
 146 <span class="special">{</span>
 147     <span class="keyword">return</span> <span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span><span class="special">;</span>
 148 <span class="special">}</span>
 149
 150 <span class="keyword">int</span> <span class="identifier">g</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="keyword">int</span> <span class="identifier">c</span><span class="special">)</span>
 151 <span class="special">{</span>
 152     <span class="keyword">return</span> <span class="identifier">a</span> <span class="special">+</span> <span class="identifier">b</span> <span class="special">+</span> <span class="identifier">c</span><span class="special">;</span>
 153 <span class="special">}</span>
 154 </pre>
 155 <p>
 156         <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">)</span></code>
 157         will produce a "nullary" function object that takes no arguments
 158         and returns <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">)</span></code>. Similarly, <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span>
 159         <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></code> is equivalent <code class="computeroutput"><span class="identifier">to</span>
 160         <span class="identifier">g</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></code>.
 161       </p>
 162 <p>
 163         It is possible to selectively bind only some of the arguments. <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span>
 164         <span class="number">5</span><span class="special">)(</span><span class="identifier">x</span><span class="special">)</span></code> is equivalent
 165         to <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="number">5</span><span class="special">)</span></code>; here <code class="computeroutput"><span class="identifier">_1</span></code>
 166         is a <span class="emphasis"><em>placeholder</em></span> argument that means "substitute
 167         with the first input argument."
 168       </p>
 169 <p>
 170         For comparison, here is the same operation expressed with the standard library
 171         primitives:
 172       </p>
 173 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind2nd</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptr_fun</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="number">5</span><span class="special">)(</span><span class="identifier">x</span><span class="special">);</span>
 174 </pre>
 175 <p>
 176         <code class="computeroutput"><span class="identifier">bind</span></code> covers the functionality
 177         of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind1st</span></code> as well:
 178       </p>
 179 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind1st</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptr_fun</span><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="number">5</span><span class="special">)(</span><span class="identifier">x</span><span class="special">);</span>   <span class="comment">// f(5, x)</span>
 180 <span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="number">5</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">x</span><span class="special">);</span>                     <span class="comment">// f(5, x)</span>
 181 </pre>
 182 <p>
 183         <code class="computeroutput"><span class="identifier">bind</span></code> can handle functions
 184         with more than two arguments, and its argument substitution mechanism is
 185         more general:
 186       </p>
 187 <pre class="programlisting"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_2</span><span class="special">,</span> <span class="identifier">_1</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">// f(y, x)</span>
 188 <span class="identifier">bind</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="number">9</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">x</span><span class="special">);</span>                 <span class="comment">// g(x, 9, x)</span>
 189 <span class="identifier">bind</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">_3</span><span class="special">,</span> <span class="identifier">_3</span><span class="special">,</span> <span class="identifier">_3</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="comment">// g(z, z, z)</span>
 190 <span class="identifier">bind</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">_1</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="comment">// g(x, x, x)</span>
 191 </pre>
 192 <p>
 193         Note that, in the last example, the function object produced by <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span>
 194         <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)</span></code> does
 195         not contain references to any arguments beyond the first, but it can still
 196         be used with more than one argument. Any extra arguments are silently ignored,
 197         just like the first and the second argument are ignored in the third example.
 198       </p>
 199 <p>
 200         The arguments that <code class="computeroutput"><span class="identifier">bind</span></code> takes
 201         are copied and held internally by the returned function object. For example,
 202         in the following code:
 203       </p>
 204 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">5</span><span class="special">;</span>
 205 <span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">);</span>
 206 </pre>
 207 <p>
 208         a copy of the value of <code class="computeroutput"><span class="identifier">i</span></code>
 209         is stored into the function object. <a href="../../../../libs/core/doc/html/core/ref.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span></code></a> and <a href="../../../../libs/core/doc/html/core/ref.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">cref</span></code></a> can be used to make the function
 210         object store a reference to an object, rather than a copy:
 211       </p>
 212 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">5</span><span class="special">;</span>
 213 <span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">ref</span><span class="special">(</span><span class="identifier">i</span><span class="special">),</span> <span class="identifier">_1</span><span class="special">);</span>
 214 <span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">cref</span><span class="special">(</span><span class="identifier">i</span><span class="special">),</span> <span class="identifier">_1</span><span class="special">);</span>
 215 </pre>
 216 </div>
 217 <div class="section">
 218 <div class="titlepage"><div><div><h3 class="title">
 219 <a name="bind.purpose.with_function_objects"></a><a class="link" href="bind.html#bind.purpose.with_function_objects" title="Using bind with function objects">Using bind with function
 220       objects</a>
 221 </h3></div></div></div>
 222 <p>
 223         <code class="computeroutput"><span class="identifier">bind</span></code> is not limited to functions;
 224         it accepts arbitrary function objects. In the general case, the return type
 225         of the generated function object's <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has to be specified explicitly (without
 226         a <code class="computeroutput"><span class="identifier">typeof</span></code> operator the return
 227         type cannot be inferred):
 228       </p>
 229 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">F</span>
 230 <span class="special">{</span>
 231     <span class="keyword">int</span> <span class="keyword">operator</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="special">{</span> <span class="keyword">return</span> <span class="identifier">a</span> <span class="special">-</span> <span class="identifier">b</span><span class="special">;</span> <span class="special">}</span>
 232     <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">long</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">b</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">a</span> <span class="special">==</span> <span class="identifier">b</span><span class="special">;</span> <span class="special">}</span>
 233 <span class="special">};</span>
 234
 235 <span class="identifier">F</span> <span class="identifier">f</span><span class="special">;</span>
 236 <span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">104</span><span class="special">;</span>
 237 <span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">x</span><span class="special">);</span>               <span class="comment">// f(x, x), i.e. zero</span>
 238 </pre>
 239 <p>
 240         Some compilers have trouble with the <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
 241         syntax. For portability reasons, an alternative way to express the above
 242         is supported:
 243       </p>
 244 <pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">type</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(),</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">x</span><span class="special">);</span>
 245 </pre>
 246 <p>
 247         Note, however, that the alternative syntax is provided only as a workaround.
 248         It is not part of the interface.
 249       </p>
 250 <p>
 251         When the function object exposes a nested type named <code class="computeroutput"><span class="identifier">result_type</span></code>,
 252         the explicit return type can be omitted:
 253       </p>
 254 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">x</span> <span class="special">=</span> <span class="number">8</span><span class="special">;</span>
 255 <span class="identifier">bind</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">int</span><span class="special">&gt;(),</span> <span class="identifier">_1</span><span class="special">,</span> <span class="number">9</span><span class="special">)(</span><span class="identifier">x</span><span class="special">);</span>     <span class="comment">// x &lt; 9</span>
 256 </pre>
 257 <p>
 258         <span class="emphasis"><em>[Note:</em></span> the ability to omit the return type is not available
 259         on all compilers.<span class="emphasis"><em>]</em></span>
 260       </p>
 261 <p>
 262         By default, <code class="computeroutput"><span class="identifier">bind</span></code> makes a
 263         copy of the provided function object. <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span></code> and
 264         <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">cref</span></code> can be used to make it store a reference
 265         to the function object, rather than a copy. This can be useful when the function
 266         object is non-copyable, expensive to copy, or contains state; of course,
 267         in this case the programmer is expected to ensure that the function object
 268         is not destroyed while it's still being used.
 269       </p>
 270 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">F2</span>
 271 <span class="special">{</span>
 272     <span class="keyword">int</span> <span class="identifier">s</span><span class="special">;</span>
 273
 274     <span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">result_type</span><span class="special">;</span>
 275     <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">s</span> <span class="special">+=</span> <span class="identifier">x</span><span class="special">;</span> <span class="special">}</span>
 276 <span class="special">};</span>
 277
 278 <span class="identifier">F2</span> <span class="identifier">f2</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</span> <span class="special">};</span>
 279 <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">2</span><span class="special">,</span> <span class="number">3</span> <span class="special">};</span>
 280
 281 <span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">a</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="identifier">bind</span><span class="special">(</span><span class="identifier">ref</span><span class="special">(</span><span class="identifier">f2</span><span class="special">),</span> <span class="identifier">_1</span><span class="special">));</span>
 282
 283 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">f2</span><span class="special">.</span><span class="identifier">s</span> <span class="special">==</span> <span class="number">6</span><span class="special">);</span>
 284 </pre>
 285 </div>
 286 <div class="section">
 287 <div class="titlepage"><div><div><h3 class="title">
 288 <a name="bind.purpose.using_bind_with_pointers_to_memb"></a><a class="link" href="bind.html#bind.purpose.using_bind_with_pointers_to_memb" title="Using bind with pointers to members">Using
 289       bind with pointers to members</a>
 290 </h3></div></div></div>
 291 <p>
 292         Pointers to member functions and pointers to data members are not function
 293         objects, because they do not support <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>. For convenience, <code class="computeroutput"><span class="identifier">bind</span></code>
 294         accepts member pointers as its first argument, and the behavior is as if
 295         <a href="../../../../libs/bind/mem_fn.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mem_fn</span></code></a>
 296         has been used to convert the member pointer into a function object. In other
 297         words, the expression
 298       </p>
 299 <pre class="programlisting"><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">args</span><span class="special">)</span>
 300 </pre>
 301 <p>
 302         is equivalent to
 303       </p>
 304 <pre class="programlisting"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><a href="../../../../libs/bind/mem_fn.html" target="_top"><code class="computeroutput"><span class="identifier">mem_fn</span></code></a><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">args</span><span class="special">)</span>
 305 </pre>
 306 <p>
 307         where <code class="computeroutput"><span class="identifier">R</span></code> is the return type
 308         of <code class="computeroutput"><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span></code> (for member functions) or the type of
 309         the member (for data members.)
 310       </p>
 311 <p>
 312         <span class="emphasis"><em>[Note:</em></span> <code class="computeroutput"><span class="identifier">mem_fn</span></code>
 313         creates function objects that are able to accept a pointer, a reference,
 314         or a smart pointer to an object as its first argument; for additional information,
 315         see the <code class="computeroutput"><span class="identifier">mem_fn</span></code> <a href="../../../../libs/bind/mem_fn.html" target="_top">documentation</a>.<span class="emphasis"><em>]</em></span>
 316       </p>
 317 <p>
 318         Example:
 319       </p>
 320 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
 321 <span class="special">{</span>
 322     <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">);</span>
 323 <span class="special">};</span>
 324
 325 <span class="identifier">X</span> <span class="identifier">x</span><span class="special">;</span>
 326 <span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;</span> <span class="identifier">p</span><span class="special">(</span><span class="keyword">new</span> <span class="identifier">X</span><span class="special">);</span>
 327 <span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">5</span><span class="special">;</span>
 328
 329 <span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">ref</span><span class="special">(</span><span class="identifier">x</span><span class="special">),</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">);</span>              <span class="comment">// x.f(i)</span>
 330 <span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">);</span>                      <span class="comment">// (&amp;x)-&gt;f(i)</span>
 331 <span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">);</span>                        <span class="comment">// (internal copy of x).f(i)</span>
 332 <span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">);</span>                        <span class="comment">// (internal copy of p)-&gt;f(i)</span>
 333 </pre>
 334 <p>
 335         The last two examples are interesting in that they produce "self-contained"
 336         function objects. <code class="computeroutput"><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">x</span><span class="special">,</span>
 337         <span class="identifier">_1</span><span class="special">)</span></code>
 338         stores a copy of <code class="computeroutput"><span class="identifier">x</span></code>. <code class="computeroutput"><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">p</span><span class="special">,</span>
 339         <span class="identifier">_1</span><span class="special">)</span></code>
 340         stores a copy of <code class="computeroutput"><span class="identifier">p</span></code>, and since
 341         <code class="computeroutput"><span class="identifier">p</span></code> is a <a href="../../../../libs/smart_ptr/doc/html/smart_ptr.html#shared_ptr" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span></code></a>, the function object
 342         retains a reference to its instance of <code class="computeroutput"><span class="identifier">X</span></code>
 343         and will remain valid even when <code class="computeroutput"><span class="identifier">p</span></code>
 344         goes out of scope or is <code class="computeroutput"><span class="identifier">reset</span><span class="special">()</span></code>.
 345       </p>
 346 </div>
 347 <div class="section">
 348 <div class="titlepage"><div><div><h3 class="title">
 349 <a name="bind.purpose.using_nested_binds_for_function_"></a><a class="link" href="bind.html#bind.purpose.using_nested_binds_for_function_" title="Using nested binds for function composition">Using
 350       nested binds for function composition</a>
 351 </h3></div></div></div>
 352 <p>
 353         Some of the arguments passed to <code class="computeroutput"><span class="identifier">bind</span></code>
 354         may be nested <span class="emphasis"><em>bind expressions</em></span> themselves:
 355       </p>
 356 <pre class="programlisting"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">))(</span><span class="identifier">x</span><span class="special">);</span>               <span class="comment">// f(g(x))</span>
 357 </pre>
 358 <p>
 359         The inner <span class="emphasis"><em>bind expressions</em></span> are evaluated, in unspecified
 360         order, before the outer <code class="computeroutput"><span class="identifier">bind</span></code>
 361         when the function object is called; the results of the evaluation are then
 362         substituted in their place when the outer <code class="computeroutput"><span class="identifier">bind</span></code>
 363         is evaluated. In the example above, when the function object is called with
 364         the argument list <code class="computeroutput"><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>, <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">g</span><span class="special">,</span>
 365         <span class="identifier">_1</span><span class="special">)(</span><span class="identifier">x</span><span class="special">)</span></code> is evaluated
 366         first, yielding <code class="computeroutput"><span class="identifier">g</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>, and
 367         then <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">g</span><span class="special">(</span><span class="identifier">x</span><span class="special">))(</span><span class="identifier">x</span><span class="special">)</span></code> is evaluated,
 368         yielding the final result <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">g</span><span class="special">(</span><span class="identifier">x</span><span class="special">))</span></code>.
 369       </p>
 370 <p>
 371         This feature of <code class="computeroutput"><span class="identifier">bind</span></code> can
 372         be used to perform function composition. See <a href="../../bind_as_compose.cpp" target="_top">bind_as_compose.cpp</a>
 373         for an example that demonstrates how to use <code class="computeroutput"><span class="identifier">bind</span></code>
 374         to achieve similar functionality to <a href="http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm" target="_top">Boost.Compose</a>.
 375       </p>
 376 <p>
 377         Note that the first argument - the bound function object - is not evaluated,
 378         even when it's a function object that is produced by <code class="computeroutput"><span class="identifier">bind</span></code>
 379         or a <span class="emphasis"><em>placeholder</em></span> argument, so the example below does
 380         not work as expected:
 381       </p>
 382 <pre class="programlisting"><span class="keyword">typedef</span> <span class="keyword">void</span> <span class="special">(*</span><span class="identifier">pf</span><span class="special">)(</span><span class="keyword">int</span><span class="special">);</span>
 383
 384 <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">pf</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
 385 <span class="identifier">std</span><span class="special">::</span><span class="identifier">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">bind</span><span class="special">(</span><span class="identifier">_1</span><span class="special">,</span> <span class="number">5</span><span class="special">));</span>
 386 </pre>
 387 <p>
 388         The desired effect can be achieved via a helper function object <code class="computeroutput"><span class="identifier">apply</span></code> that applies its first argument,
 389         as a function object, to the rest of its argument list. For convenience,
 390         an implementation of <code class="computeroutput"><span class="identifier">apply</span></code>
 391         is provided in the <a href="../../../../boost/bind/apply.hpp" target="_top">apply.hpp</a>
 392         header file. Here is how the modified version of the previous example looks
 393         like:
 394       </p>
 395 <pre class="programlisting"><span class="keyword">typedef</span> <span class="keyword">void</span> <span class="special">(*</span><span class="identifier">pf</span><span class="special">)(</span><span class="keyword">int</span><span class="special">);</span>
 396
 397 <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">pf</span><span class="special">&gt;</span> <span class="identifier">v</span><span class="special">;</span>
 398 <span class="identifier">std</span><span class="special">::</span><span class="identifier">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">bind</span><span class="special">(</span><span class="identifier">apply</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;(),</span> <span class="identifier">_1</span><span class="special">,</span> <span class="number">5</span><span class="special">));</span>
 399 </pre>
 400 <p>
 401         Although the first argument is, by default, not evaluated, all other arguments
 402         are. Sometimes it is necessary not to evaluate arguments subsequent to the
 403         first, even when they are nested <span class="emphasis"><em>bind subexpressions</em></span>.
 404         This can be achieved with the help of another function object, <code class="computeroutput"><span class="identifier">protect</span></code>, that masks the type so that <code class="computeroutput"><span class="identifier">bind</span></code> does not recognize and evaluate it.
 405         When called, protect simply forwards the argument list to the other function
 406         object unmodified.
 407       </p>
 408 <p>
 409         The header <a href="../../../../boost/bind/protect.hpp" target="_top">protect.hpp</a>
 410         contains an implementation of <code class="computeroutput"><span class="identifier">protect</span></code>.
 411         To <code class="computeroutput"><span class="identifier">protect</span></code> a bind function
 412         object from evaluation, use <code class="computeroutput"><span class="identifier">protect</span><span class="special">(</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...))</span></code>.
 413       </p>
 414 </div>
 415 <div class="section">
 416 <div class="titlepage"><div><div><h3 class="title">
 417 <a name="bind.purpose.overloaded_operators_new_in_boos"></a><a class="link" href="bind.html#bind.purpose.overloaded_operators_new_in_boos" title="Overloaded operators (new in Boost 1.33)">Overloaded
 418       operators (new in Boost 1.33)</a>
 419 </h3></div></div></div>
 420 <p>
 421         For convenience, the function objects produced by <code class="computeroutput"><span class="identifier">bind</span></code>
 422         overload the logical not operator <code class="computeroutput"><span class="special">!</span></code>
 423         and the relational and logical operators <code class="computeroutput"><span class="special">==,</span>
 424         <span class="special">!=,</span> <span class="special">&lt;,</span>
 425         <span class="special">&lt;=,</span> <span class="special">&gt;,</span>
 426         <span class="special">&gt;=,</span> <span class="special">&amp;&amp;,</span>
 427         <span class="special">||</span></code>.
 428       </p>
 429 <p>
 430         <code class="computeroutput"><span class="special">!</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span>
 431         <span class="special">...)</span></code> is equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">logical_not</span><span class="special">(),</span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span>
 432         <span class="special">...))</span></code>, where <code class="computeroutput"><span class="identifier">logical_not</span></code>
 433         is a function object that takes one argument <code class="computeroutput"><span class="identifier">x</span></code>
 434         and returns <code class="computeroutput"><span class="special">!</span><span class="identifier">x</span></code>.
 435       </p>
 436 <p>
 437         <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span>
 438         <span class="identifier">op</span> <span class="identifier">x</span></code>,
 439         where <span class="underline">op</span> is a relational or logical
 440         operator, is equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">relation</span><span class="special">(),</span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span>
 441         <span class="special">...),</span> <span class="identifier">x</span><span class="special">)</span></code>, where <code class="computeroutput"><span class="identifier">relation</span></code>
 442         is a function object that takes two arguments <code class="computeroutput"><span class="identifier">a</span></code>
 443         and <code class="computeroutput"><span class="identifier">b</span></code> and returns <code class="computeroutput"><span class="identifier">a</span> <span class="identifier">op</span> <span class="identifier">b</span></code>.
 444       </p>
 445 <p>
 446         What this means in practice is that you can conveniently negate the result
 447         of <code class="computeroutput"><span class="identifier">bind</span></code>:
 448       </p>
 449 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">remove_if</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">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">visible</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">));</span> <span class="comment">// remove invisible objects</span>
 450 </pre>
 451 <p>
 452         and compare the result of <code class="computeroutput"><span class="identifier">bind</span></code>
 453         against a value:
 454       </p>
 455 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">find_if</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">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)</span> <span class="special">==</span> <span class="string">"Peter"</span><span class="special">);</span>
 456 <span class="identifier">std</span><span class="special">::</span><span class="identifier">find_if</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">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)</span> <span class="special">==</span> <span class="string">"Peter"</span> <span class="special">||</span> <span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)</span> <span class="special">==</span> <span class="string">"Paul"</span><span class="special">);</span>
 457 </pre>
 458 <p>
 459         against a <span class="emphasis"><em>placeholder</em></span>:
 460       </p>
 461 <pre class="programlisting"><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">_2</span>
 462 </pre>
 463 <p>
 464         or against another <span class="emphasis"><em>bind expression</em></span>:
 465       </p>
 466 <pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">sort</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">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)</span> <span class="special">&lt;</span> <span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">_2</span><span class="special">));</span> <span class="comment">// sort by name</span>
 467 </pre>
 468 </div>
 469 </div>
 470 <div class="section">
 471 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 472 <a name="bind.examples"></a><a class="link" href="bind.html#bind.examples" title="Examples">Examples</a>
 473 </h2></div></div></div>
 474 <div class="section">
 475 <div class="titlepage"><div><div><h3 class="title">
 476 <a name="bind.examples.using_bind_with_standard_algorit"></a><a class="link" href="bind.html#bind.examples.using_bind_with_standard_algorit" title="Using bind with standard algorithms">Using
 477       bind with standard algorithms</a>
 478 </h3></div></div></div>
 479 <pre class="programlisting"><span class="keyword">class</span> <span class="identifier">image</span><span class="special">;</span>
 480
 481 <span class="keyword">class</span> <span class="identifier">animation</span>
 482 <span class="special">{</span>
 483 <span class="keyword">public</span><span class="special">:</span>
 484     <span class="keyword">void</span> <span class="identifier">advance</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">ms</span><span class="special">);</span>
 485     <span class="keyword">bool</span> <span class="identifier">inactive</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 486     <span class="keyword">void</span> <span class="identifier">render</span><span class="special">(</span><span class="identifier">image</span> <span class="special">&amp;</span> <span class="identifier">target</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
 487 <span class="special">};</span>
 488
 489 <span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">animation</span><span class="special">&gt;</span> <span class="identifier">anims</span><span class="special">;</span>
 490
 491 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">P</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">erase_if</span><span class="special">(</span><span class="identifier">C</span> <span class="special">&amp;</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">P</span> <span class="identifier">pred</span><span class="special">)</span>
 492 <span class="special">{</span>
 493     <span class="identifier">c</span><span class="special">.</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">remove_if</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">pred</span><span class="special">),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
 494 <span class="special">}</span>
 495
 496 <span class="keyword">void</span> <span class="identifier">update</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">ms</span><span class="special">)</span>
 497 <span class="special">{</span>
 498     <span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">anims</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">anims</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">animation</span><span class="special">::</span><span class="identifier">advance</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">ms</span><span class="special">));</span>
 499     <span class="identifier">erase_if</span><span class="special">(</span><span class="identifier">anims</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">mem_fn</span><span class="special">(&amp;</span><span class="identifier">animation</span><span class="special">::</span><span class="identifier">inactive</span><span class="special">));</span>
 500 <span class="special">}</span>
 501
 502 <span class="keyword">void</span> <span class="identifier">render</span><span class="special">(</span><span class="identifier">image</span> <span class="special">&amp;</span> <span class="identifier">target</span><span class="special">)</span>
 503 <span class="special">{</span>
 504     <span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">anims</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">anims</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">animation</span><span class="special">::</span><span class="identifier">render</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span><span class="identifier">target</span><span class="special">)));</span>
 505 <span class="special">}</span>
 506 </pre>
 507 </div>
 508 <div class="section">
 509 <div class="titlepage"><div><div><h3 class="title">
 510 <a name="bind.examples.using_bind_with_boost_function"></a><a class="link" href="bind.html#bind.examples.using_bind_with_boost_function" title="Using bind with Boost.Function">Using bind
 511       with Boost.Function</a>
 512 </h3></div></div></div>
 513 <pre class="programlisting"><span class="keyword">class</span> <span class="identifier">button</span>
 514 <span class="special">{</span>
 515 <span class="keyword">public</span><span class="special">:</span>
 516     <a href="../../../../libs/function/index.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">function</span></code></a><span class="special">&lt;</span><span class="keyword">void</span><span class="special">()&gt;</span> <span class="identifier">onClick</span><span class="special">;</span>
 517 <span class="special">};</span>
 518
 519 <span class="keyword">class</span> <span class="identifier">player</span>
 520 <span class="special">{</span>
 521 <span class="keyword">public</span><span class="special">:</span>
 522     <span class="keyword">void</span> <span class="identifier">play</span><span class="special">();</span>
 523     <span class="keyword">void</span> <span class="identifier">stop</span><span class="special">();</span>
 524 <span class="special">};</span>
 525
 526 <span class="identifier">button</span> <span class="identifier">playButton</span><span class="special">,</span> <span class="identifier">stopButton</span><span class="special">;</span>
 527 <span class="identifier">player</span> <span class="identifier">thePlayer</span><span class="special">;</span>
 528
 529 <span class="keyword">void</span> <span class="identifier">connect</span><span class="special">()</span>
 530 <span class="special">{</span>
 531     <span class="identifier">playButton</span><span class="special">.</span><span class="identifier">onClick</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">player</span><span class="special">::</span><span class="identifier">play</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">thePlayer</span><span class="special">);</span>
 532     <span class="identifier">stopButton</span><span class="special">.</span><span class="identifier">onClick</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">player</span><span class="special">::</span><span class="identifier">stop</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">thePlayer</span><span class="special">);</span>
 533 <span class="special">}</span>
 534 </pre>
 535 </div>
 536 </div>
 537 <div class="section">
 538 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 539 <a name="bind.limitations"></a><a class="link" href="bind.html#bind.limitations" title="Limitations">Limitations</a>
 540 </h2></div></div></div>
 541 <p>
 542       As a general rule, the function objects generated by <code class="computeroutput"><span class="identifier">bind</span></code>
 543       take their arguments by reference and cannot, therefore, accept non-const temporaries
 544       or literal constants. This is an inherent limitation of the C++ language in
 545       its current (2003) incarnation, known as the <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_top">forwarding
 546       problem</a>. (It will be fixed in the next standard, usually called C++0x.)
 547     </p>
 548 <p>
 549       The library uses signatures of the form
 550     </p>
 551 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">T</span> <span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
 552 </pre>
 553 <p>
 554       to accept arguments of arbitrary types and pass them on unmodified. As noted,
 555       this does not work with non-const r-values.
 556     </p>
 557 <p>
 558       On compilers that support partial ordering of function templates, a possible
 559       solution is to add an overload:
 560     </p>
 561 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">T</span> <span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
 562 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">t</span><span class="special">);</span>
 563 </pre>
 564 <p>
 565       Unfortunately, this requires providing 512 overloads for nine arguments, which
 566       is impractical. The library chooses a small subset: for up to two arguments,
 567       it provides the const overloads in full, for arities of three and more it provides
 568       a single additional overload with all of the arguments taken by const reference.
 569       This covers a reasonable portion of the use cases.
 570     </p>
 571 </div>
 572 <div class="section">
 573 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 574 <a name="bind.faq"></a><a class="link" href="bind.html#bind.faq" title="Frequently Asked Questions">Frequently Asked Questions</a>
 575 </h2></div></div></div>
 576 <div class="section">
 577 <div class="titlepage"><div><div><h3 class="title">
 578 <a name="bind.faq.why_doesn_t_this_compile"></a><a class="link" href="bind.html#bind.faq.why_doesn_t_this_compile" title="Why doesn't this compile?">Why doesn't this compile?</a>
 579 </h3></div></div></div>
 580 <p>
 581         See the dedicated <a class="link" href="bind.html#bind.troubleshooting" title="Troubleshooting">Troubleshooting section</a>.
 582       </p>
 583 </div>
 584 <div class="section">
 585 <div class="titlepage"><div><div><h3 class="title">
 586 <a name="bind.faq.why_does_this_compile_it_should_"></a><a class="link" href="bind.html#bind.faq.why_does_this_compile_it_should_" title="Why does this compile? It should not.">Why does this
 587       compile? It should not.</a>
 588 </h3></div></div></div>
 589 <p>
 590         Probably because you used the general <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
 591         syntax, thereby instructing <code class="computeroutput"><span class="identifier">bind</span></code>
 592         to not "inspect" f to detect arity and return type errors.
 593       </p>
 594 </div>
 595 <div class="section">
 596 <div class="titlepage"><div><div><h3 class="title">
 597 <a name="bind.faq.Q_forms"></a><a class="link" href="bind.html#bind.faq.Q_forms" title="What is the difference between bind(f, ...) and bind&lt;R&gt;(f, ...)?">What is the difference between <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code> and
 598       <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>?</a>
 599 </h3></div></div></div>
 600 <p>
 601         The first form instructs <code class="computeroutput"><span class="identifier">bind</span></code>
 602         to inspect the type of <code class="computeroutput"><span class="identifier">f</span></code>
 603         in order to determine its arity (number of arguments) and return type. Arity
 604         errors will be detected at "bind time". This syntax, of course,
 605         places some requirements on <code class="computeroutput"><span class="identifier">f</span></code>.
 606         It must be a function, function pointer, member function pointer, or a function
 607         object that defines a nested type named <code class="computeroutput"><span class="identifier">result_type</span></code>;
 608         in short, it must be something that <code class="computeroutput"><span class="identifier">bind</span></code>
 609         can recognize.
 610       </p>
 611 <p>
 612         The second form instructs <code class="computeroutput"><span class="identifier">bind</span></code>
 613         to not attempt to recognize the type of <code class="computeroutput"><span class="identifier">f</span></code>.
 614         It is generally used with function objects that do not, or cannot, expose
 615         <code class="computeroutput"><span class="identifier">result_type</span></code>, but it can also
 616         be used with nonstandard functions. For example, the current implementation
 617         does not automatically recognize variable-argument functions like <code class="computeroutput"><span class="identifier">printf</span></code>, so you will have to use <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">printf</span><span class="special">,</span> <span class="special">...)</span></code>. Note
 618         that an alternative <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">type</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(),</span> <span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
 619         syntax is supported for portability reasons.
 620       </p>
 621 <p>
 622         Another important factor to consider is that compilers without partial template
 623         specialization or function template partial ordering support cannot handle
 624         the first form when <code class="computeroutput"><span class="identifier">f</span></code> is
 625         a function object, and in most cases will not handle the second form when
 626         <code class="computeroutput"><span class="identifier">f</span></code> is a function (pointer)
 627         or a member function pointer.
 628       </p>
 629 </div>
 630 <div class="section">
 631 <div class="titlepage"><div><div><h3 class="title">
 632 <a name="bind.faq.does_bind_work_with_windows_api_"></a><a class="link" href="bind.html#bind.faq.does_bind_work_with_windows_api_" title="Does bind work with Windows API functions?">Does bind
 633       work with Windows API functions?</a>
 634 </h3></div></div></div>
 635 <p>
 636         Yes, if you <a class="link" href="bind.html#bind.implementation.stdcall" title="__stdcall, __cdecl, __fastcall, and pascal Support"><code class="computeroutput"><span class="preprocessor">#define</span>
 637         <span class="identifier">BOOST_BIND_ENABLE_STDCALL</span></code></a>.
 638         An alternative is to treat the function as a <a class="link" href="bind.html#bind.purpose.with_function_objects" title="Using bind with function objects">generic
 639         function object</a> and use the <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
 640         syntax.
 641       </p>
 642 </div>
 643 <div class="section">
 644 <div class="titlepage"><div><div><h3 class="title">
 645 <a name="bind.faq.does_bind_work_with_com_methods"></a><a class="link" href="bind.html#bind.faq.does_bind_work_with_com_methods" title="Does bind work with COM methods?">Does bind work
 646       with COM methods?</a>
 647 </h3></div></div></div>
 648 <p>
 649         Yes, if you <a class="link" href="bind.html#bind.implementation.stdcall" title="__stdcall, __cdecl, __fastcall, and pascal Support"><code class="computeroutput"><span class="preprocessor">#define</span>
 650         <span class="identifier">BOOST_MEM_FN_ENABLE_STDCALL</span></code></a>.
 651       </p>
 652 </div>
 653 <div class="section">
 654 <div class="titlepage"><div><div><h3 class="title">
 655 <a name="bind.faq.does_bind_work_with_mac_toolbox_"></a><a class="link" href="bind.html#bind.faq.does_bind_work_with_mac_toolbox_" title="Does bind work with Mac toolbox functions?">Does bind
 656       work with Mac toolbox functions?</a>
 657 </h3></div></div></div>
 658 <p>
 659         Yes, if you <a class="link" href="bind.html#bind.implementation.stdcall" title="__stdcall, __cdecl, __fastcall, and pascal Support"><code class="computeroutput"><span class="preprocessor">#define</span>
 660         <span class="identifier">BOOST_BIND_ENABLE_PASCAL</span></code></a>.
 661         An alternative is to treat the function as a <a class="link" href="bind.html#bind.purpose.with_function_objects" title="Using bind with function objects">generic
 662         function object</a> and use the <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
 663         syntax.
 664       </p>
 665 </div>
 666 <div class="section">
 667 <div class="titlepage"><div><div><h3 class="title">
 668 <a name="bind.faq.does_bind_work_with_extern_c_fun"></a><a class="link" href="bind.html#bind.faq.does_bind_work_with_extern_c_fun" title='Does bind work with extern "C" functions?'>Does bind
 669       work with extern "C" functions?</a>
 670 </h3></div></div></div>
 671 <p>
 672         Sometimes. On some platforms, pointers to extern "C" functions
 673         are equivalent to "ordinary" function pointers, so they work fine.
 674         Other platforms treat them as different types. A platform-specific implementation
 675         of <code class="computeroutput"><span class="identifier">bind</span></code> is expected to handle
 676         the problem transparently; this implementation does not. As usual, the workaround
 677         is to treat the function as a <a class="link" href="bind.html#bind.purpose.with_function_objects" title="Using bind with function objects">generic
 678         function object</a> and use the <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
 679         syntax.
 680       </p>
 681 </div>
 682 <div class="section">
 683 <div class="titlepage"><div><div><h3 class="title">
 684 <a name="bind.faq.why_doesn_t_bind_automatically_r"></a><a class="link" href="bind.html#bind.faq.why_doesn_t_bind_automatically_r" title="Why doesn't bind automatically recognize nonstandard functions?">Why doesn't
 685       bind automatically recognize nonstandard functions?</a>
 686 </h3></div></div></div>
 687 <p>
 688         Non-portable extensions, in general, should default to off to prevent vendor
 689         lock-in. Had the <a class="link" href="bind.html#bind.implementation.stdcall" title="__stdcall, __cdecl, __fastcall, and pascal Support">appropriate
 690         macros</a> been defined automatically, you could have accidentally taken
 691         advantage of them without realizing that your code is, perhaps, no longer
 692         portable. In addition, some compilers have the option to make <code class="computeroutput"><span class="identifier">__stdcall</span></code> (<code class="computeroutput"><span class="identifier">__fastcall</span></code>)
 693         their default calling convention, in which case no separate support would
 694         be necessary.
 695       </p>
 696 </div>
 697 </div>
 698 <div class="section">
 699 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 700 <a name="bind.troubleshooting"></a><a class="link" href="bind.html#bind.troubleshooting" title="Troubleshooting">Troubleshooting</a>
 701 </h2></div></div></div>
 702 <div class="section">
 703 <div class="titlepage"><div><div><h3 class="title">
 704 <a name="bind.troubleshooting.incorrect_number_of_arguments"></a><a class="link" href="bind.html#bind.troubleshooting.incorrect_number_of_arguments" title="Incorrect number of arguments">Incorrect
 705       number of arguments</a>
 706 </h3></div></div></div>
 707 <p>
 708         In a <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span>
 709         <span class="special">...,</span> <span class="identifier">aN</span><span class="special">)</span></code> expression, the function object <code class="computeroutput"><span class="identifier">f</span></code> must be able to take exactly N arguments.
 710         This error is normally detected at "bind time"; in other words,
 711         the compilation error is reported on the line where <code class="computeroutput"><span class="identifier">bind</span><span class="special">()</span></code> is invoked:
 712       </p>
 713 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">);</span>
 714
 715 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 716 <span class="special">{</span>
 717     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>    <span class="comment">// error, f takes two arguments</span>
 718     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</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="comment">// OK</span>
 719 <span class="special">}</span>
 720 </pre>
 721 <p>
 722         A common variation of this error is to forget that member functions have
 723         an implicit "this" argument:
 724       </p>
 725 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
 726 <span class="special">{</span>
 727     <span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
 728 <span class="special">}</span>
 729
 730 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 731 <span class="special">{</span>
 732     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>     <span class="comment">// error, X::f takes two arguments</span>
 733     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span> <span class="comment">// OK</span>
 734 <span class="special">}</span>
 735 </pre>
 736 </div>
 737 <div class="section">
 738 <div class="titlepage"><div><div><h3 class="title">
 739 <a name="bind.troubleshooting.the_function_object_cannot_be_ca"></a><a class="link" href="bind.html#bind.troubleshooting.the_function_object_cannot_be_ca" title="The function object cannot be called with the specified arguments">The
 740       function object cannot be called with the specified arguments</a>
 741 </h3></div></div></div>
 742 <p>
 743         As in normal function calls, the function object that is bound must be compatible
 744         with the argument list. The incompatibility will usually be detected by the
 745         compiler at "call time" and the result is typically an error in
 746         <code class="computeroutput"><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span></code> on a line that looks like:
 747       </p>
 748 <pre class="programlisting"><span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">a</span><span class="special">[</span><span class="identifier">a1_</span><span class="special">],</span> <span class="identifier">a</span><span class="special">[</span><span class="identifier">a2_</span><span class="special">]);</span>
 749 </pre>
 750 <p>
 751         An example of this kind of error:
 752       </p>
 753 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
 754
 755 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 756 <span class="special">{</span>
 757     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="string">"incompatible"</span><span class="special">);</span>      <span class="comment">// OK so far, no call</span>
 758     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="string">"incompatible"</span><span class="special">)();</span>    <span class="comment">// error, "incompatible" is not an int</span>
 759     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">);</span>                  <span class="comment">// OK</span>
 760     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)(</span><span class="string">"incompatible"</span><span class="special">);</span>  <span class="comment">// error, "incompatible" is not an int</span>
 761 <span class="special">}</span>
 762 </pre>
 763 </div>
 764 <div class="section">
 765 <div class="titlepage"><div><div><h3 class="title">
 766 <a name="bind.troubleshooting.accessing_an_argument_that_does_"></a><a class="link" href="bind.html#bind.troubleshooting.accessing_an_argument_that_does_" title="Accessing an argument that does not exist">Accessing
 767       an argument that does not exist</a>
 768 </h3></div></div></div>
 769 <p>
 770         The placeholder <code class="computeroutput"><span class="identifier">_N</span></code> selects
 771         the argument at position <code class="computeroutput"><span class="identifier">N</span></code>
 772         from the argument list passed at "call time." Naturally, it is
 773         an error to attempt to access beyond the end of this list:
 774       </p>
 775 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
 776
 777 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 778 <span class="special">{</span>
 779     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">);</span>                  <span class="comment">// OK</span>
 780     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)();</span>                <span class="comment">// error, there is no argument number 1</span>
 781 <span class="special">}</span>
 782 </pre>
 783 <p>
 784         The error is usually reported in <code class="computeroutput"><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span></code>, at
 785         a line similar to:
 786       </p>
 787 <pre class="programlisting"><span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">a</span><span class="special">[</span><span class="identifier">a1_</span><span class="special">]);</span>
 788 </pre>
 789 <p>
 790         When emulating <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bind1st</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a</span><span class="special">)</span></code>, a common mistake of this category is to
 791         type <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">_2</span><span class="special">)</span></code>
 792         instead of the correct <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span>
 793         <span class="identifier">a</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)</span></code>.
 794       </p>
 795 </div>
 796 <div class="section">
 797 <div class="titlepage"><div><div><h3 class="title">
 798 <a name="bind.troubleshooting.inappropriate_use_of_bind_f"></a><a class="link" href="bind.html#bind.troubleshooting.inappropriate_use_of_bind_f" title="Inappropriate use of bind(f, ...)">Inappropriate
 799       use of <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code></a>
 800 </h3></div></div></div>
 801 <p>
 802         The <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span>
 803         <span class="special">...,</span> <span class="identifier">aN</span><span class="special">)</span></code> <a class="link" href="bind.html#bind.faq.Q_forms" title="What is the difference between bind(f, ...) and bind&lt;R&gt;(f, ...)?">form</a>
 804         causes automatic recognition of the type of <code class="computeroutput"><span class="identifier">f</span></code>.
 805         It will not work with arbitrary function objects; <code class="computeroutput"><span class="identifier">f</span></code>
 806         must be a function or a member function pointer.
 807       </p>
 808 <p>
 809         It is possible to use this form with function objects that define <code class="computeroutput"><span class="identifier">result_type</span></code>, but only on compilers that
 810         support partial specialization and partial ordering. In particular, MSVC
 811         up to version 7.0 does not support this syntax for function objects.
 812       </p>
 813 </div>
 814 <div class="section">
 815 <div class="titlepage"><div><div><h3 class="title">
 816 <a name="bind.troubleshooting.inappropriate_use_of_bind_r_f"></a><a class="link" href="bind.html#bind.troubleshooting.inappropriate_use_of_bind_r_f" title="Inappropriate use of bind&lt;R&gt;(f, ...)">Inappropriate
 817       use of <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code></a>
 818 </h3></div></div></div>
 819 <p>
 820         The <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span>
 821         <span class="special">...,</span> <span class="identifier">aN</span><span class="special">)</span></code> <a class="link" href="bind.html#bind.faq.Q_forms" title="What is the difference between bind(f, ...) and bind&lt;R&gt;(f, ...)?">form</a>
 822         supports arbitrary function objects.
 823       </p>
 824 <p>
 825         It is possible (but not recommended) to use this form with functions or member
 826         function pointers, but only on compilers that support partial ordering. In
 827         particular, MSVC up to version 7.0 does not fully support this syntax for
 828         functions and member function pointers.
 829       </p>
 830 </div>
 831 <div class="section">
 832 <div class="titlepage"><div><div><h3 class="title">
 833 <a name="bind.troubleshooting.binding_a_nonstandard_function"></a><a class="link" href="bind.html#bind.troubleshooting.binding_a_nonstandard_function" title="Binding a nonstandard function">Binding
 834       a nonstandard function</a>
 835 </h3></div></div></div>
 836 <p>
 837         By default, the <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span>
 838         <span class="special">...,</span> <span class="identifier">aN</span><span class="special">)</span></code> <a class="link" href="bind.html#bind.faq.Q_forms" title="What is the difference between bind(f, ...) and bind&lt;R&gt;(f, ...)?">form</a>
 839         recognizes "ordinary" C++ functions and function pointers. <a class="link" href="bind.html#bind.implementation.stdcall" title="__stdcall, __cdecl, __fastcall, and pascal Support">Functions that use a different calling
 840         convention</a>, or variable-argument functions such as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">printf</span></code>,
 841         do not work. The general <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span>
 842         <span class="special">...,</span> <span class="identifier">aN</span><span class="special">)</span></code> <a class="link" href="bind.html#bind.faq.Q_forms" title="What is the difference between bind(f, ...) and bind&lt;R&gt;(f, ...)?">form</a>
 843         works with nonstandard functions.
 844       </p>
 845 <p>
 846         On some platforms, extern "C" functions, like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">strcmp</span></code>,
 847         are not recognized by the short form of <code class="computeroutput"><span class="identifier">bind</span></code>.
 848       </p>
 849 <p>
 850         See also <a class="link" href="bind.html#bind.implementation.stdcall" title="__stdcall, __cdecl, __fastcall, and pascal Support"><code class="computeroutput"><span class="identifier">__stdcall</span></code>
 851         and <code class="computeroutput"><span class="identifier">pascal</span></code> Support</a>.
 852       </p>
 853 </div>
 854 <div class="section">
 855 <div class="titlepage"><div><div><h3 class="title">
 856 <a name="bind.troubleshooting.binding_an_overloaded_function"></a><a class="link" href="bind.html#bind.troubleshooting.binding_an_overloaded_function" title="Binding an overloaded function">Binding
 857       an overloaded function</a>
 858 </h3></div></div></div>
 859 <p>
 860         An attempt to bind an overloaded function usually results in an error, as
 861         there is no way to tell which overload was meant to be bound. This is a common
 862         problem with member functions with two overloads, const and non-const, as
 863         in this simplified example:
 864       </p>
 865 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
 866 <span class="special">{</span>
 867     <span class="keyword">int</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">();</span>
 868     <span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
 869 <span class="special">};</span>
 870
 871 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 872 <span class="special">{</span>
 873     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">);</span>
 874 <span class="special">}</span>
 875 </pre>
 876 <p>
 877         The ambiguity can be resolved manually by casting the (member) function pointer
 878         to the desired type:
 879       </p>
 880 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 881 <span class="special">{</span>
 882     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span> <span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">(</span><span class="identifier">X</span><span class="special">::*)</span> <span class="special">()</span> <span class="keyword">const</span> <span class="special">&gt;(&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">),</span> <span class="identifier">_1</span><span class="special">);</span>
 883 <span class="special">}</span>
 884 </pre>
 885 <p>
 886         Another, arguably more readable, alternative is to introduce a temporary
 887         variable:
 888       </p>
 889 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 890 <span class="special">{</span>
 891     <span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">get</span><span class="special">)</span> <span class="special">()</span> <span class="keyword">const</span> <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">get</span><span class="special">;</span>
 892     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">get</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">);</span>
 893 <span class="special">}</span>
 894 </pre>
 895 </div>
 896 <div class="section">
 897 <div class="titlepage"><div><div><h3 class="title">
 898 <a name="bind.troubleshooting.modeling_stl_function_object_con"></a><a class="link" href="bind.html#bind.troubleshooting.modeling_stl_function_object_con" title="Modeling STL function object concepts">Modeling
 899       STL function object concepts</a>
 900 </h3></div></div></div>
 901 <p>
 902         The function objects that are produced by <code class="computeroutput"><span class="identifier">bind</span></code>
 903         do not model the STL <a href="https://boost.org/sgi/stl/UnaryFunction.html" target="_top"><span class="emphasis"><em>Unary
 904         Function</em></span></a> or <a href="https://boost.org/sgi/stl/BinaryFunction.html" target="_top"><span class="emphasis"><em>Binary
 905         Function</em></span></a> concepts, even when the function objects are
 906         unary or binary operations, because the function object types are missing
 907         public typedefs <code class="computeroutput"><span class="identifier">result_type</span></code>
 908         and <code class="computeroutput"><span class="identifier">argument_type</span></code> or <code class="computeroutput"><span class="identifier">first_argument_type</span></code> and <code class="computeroutput"><span class="identifier">second_argument_type</span></code>.
 909         In cases where these typedefs are desirable, however, the utility function
 910         <code class="computeroutput"><span class="identifier">make_adaptable</span></code> can be used
 911         to adapt unary and binary function objects to these concepts. This allows
 912         unary and binary function objects resulting from <code class="computeroutput"><span class="identifier">bind</span></code>
 913         to be combined with STL templates such as <a href="http://en.cppreference.com/w/cpp/utility/functional/unary_negate" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unary_negate</span></code></a>
 914         and <a href="http://en.cppreference.com/w/cpp/utility/functional/binary_negate" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">binary_negate</span></code></a>.
 915       </p>
 916 <p>
 917         The <code class="computeroutput"><span class="identifier">make_adaptable</span></code> function
 918         is defined in <a href="../../../../boost/bind/make_adaptable.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">/</span><span class="identifier">make_adaptable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>,
 919         which must be included explicitly in addition to <a href="../../../../boost/bind.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>:
 920       </p>
 921 <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">bind</span><span class="special">/</span><span class="identifier">make_adaptable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 922
 923 <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-type</em></span> <span class="identifier">make_adaptable</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">);</span>
 924
 925 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-unary-functional-type</em></span> <span class="identifier">make_adaptable</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">);</span>
 926
 927 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-binary-functional-type</em></span> <span class="identifier">make_adaptable</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">);</span>
 928
 929 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-ternary-functional-type</em></span> <span class="identifier">make_adaptable</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">);</span>
 930
 931 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A3</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A4</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-4-ary-functional-type</em></span> <span class="identifier">make_adaptable</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">);</span>
 932 </pre>
 933 <p>
 934         This example shows how to use <code class="computeroutput"><span class="identifier">make_adaptable</span></code>
 935         to make a predicate for "is not a space":
 936       </p>
 937 <pre class="programlisting"><span class="keyword">typedef</span> <span class="keyword">char</span> <span class="identifier">char_t</span><span class="special">;</span>
 938 <span class="identifier">std</span><span class="special">::</span><span class="identifier">locale</span> <span class="identifier">loc</span><span class="special">(</span><span class="string">""</span><span class="special">);</span>
 939 <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ctype</span><span class="special">&lt;</span><span class="identifier">char_t</span><span class="special">&gt;&amp;</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">use_facet</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ctype</span><span class="special">&lt;</span><span class="identifier">char_t</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="identifier">loc</span><span class="special">);</span>
 940
 941 <span class="keyword">auto</span> <span class="identifier">isntspace</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">not1</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">make_adaptable</span><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">char_t</span><span class="special">&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(&amp;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ctype</span><span class="special">&lt;</span><span class="identifier">char_t</span><span class="special">&gt;::</span><span class="identifier">is</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">ct</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ctype_base</span><span class="special">::</span><span class="identifier">space</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">)));</span>
 942 </pre>
 943 <p>
 944         In this example, <code class="computeroutput"><span class="identifier">bind</span></code> creates
 945         the "is a space" (unary) predicate. It is then passed to <code class="computeroutput"><span class="identifier">make_adaptable</span></code> so that a function object
 946         modeling the <span class="emphasis"><em>Unary Function</em></span> concept can be created,
 947         serving as the argument to <a href="http://en.cppreference.com/w/cpp/utility/functional/not1" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">not1</span></code></a>.
 948       </p>
 949 </div>
 950 <div class="section">
 951 <div class="titlepage"><div><div><h3 class="title">
 952 <a name="bind.troubleshooting.const_in_signatures"></a><a class="link" href="bind.html#bind.troubleshooting.const_in_signatures" title="const in signatures"><code class="computeroutput"><span class="keyword">const</span></code> in signatures</a>
 953 </h3></div></div></div>
 954 <p>
 955         Some compilers, including MSVC 6.0 and Borland C++ 5.5.1, have problems with
 956         the top-level <code class="computeroutput"><span class="keyword">const</span></code> in function
 957         signatures:
 958       </p>
 959 <pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">);</span>
 960
 961 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 962 <span class="special">{</span>
 963     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span>     <span class="comment">// error</span>
 964 <span class="special">}</span>
 965 </pre>
 966 <p>
 967         Workaround: remove the <code class="computeroutput"><span class="keyword">const</span></code>
 968         qualifier from the argument.
 969       </p>
 970 </div>
 971 <div class="section">
 972 <div class="titlepage"><div><div><h3 class="title">
 973 <a name="bind.troubleshooting.msvc_specific_using_boost_bind"></a><a class="link" href="bind.html#bind.troubleshooting.msvc_specific_using_boost_bind" title="MSVC specific: using boost::bind;">MSVC
 974       specific: <code class="computeroutput"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">;</span></code></a>
 975 </h3></div></div></div>
 976 <p>
 977         On MSVC (up to version 7.0), when <code class="computeroutput"><span class="identifier">boostbind</span></code>
 978         is brought into scope with an using declaration:
 979       </p>
 980 <pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">;</span>
 981 </pre>
 982 <p>
 983         the syntax <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
 984         does not work. Workaround: either use the qualified name, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span></code>,
 985         or use an using directive instead:
 986       </p>
 987 <pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">;</span>
 988 </pre>
 989 </div>
 990 <div class="section">
 991 <div class="titlepage"><div><div><h3 class="title">
 992 <a name="bind.troubleshooting.msvc_specific_class_templates_sh"></a><a class="link" href="bind.html#bind.troubleshooting.msvc_specific_class_templates_sh" title="MSVC specific: class templates shadow function templates">MSVC
 993       specific: class templates shadow function templates</a>
 994 </h3></div></div></div>
 995 <p>
 996         On MSVC (up to version 7.0), a nested class template named <code class="computeroutput"><span class="identifier">bind</span></code> will shadow the function template
 997         <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span></code>, breaking the <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>syntax.
 998         Unfortunately, some libraries contain nested class templates named <code class="computeroutput"><span class="identifier">bind</span></code> (ironically, such code is often an
 999         MSVC specific workaround.)
1000       </p>
1001 <p>
1002         The workaround is to use the alternative <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">type</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(),</span> <span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
1003         syntax.
1004       </p>
1005 </div>
1006 <div class="section">
1007 <div class="titlepage"><div><div><h3 class="title">
1008 <a name="bind.troubleshooting.msvc_specific_in_signatures_trea"></a><a class="link" href="bind.html#bind.troubleshooting.msvc_specific_in_signatures_trea" title="MSVC specific: ... in signatures treated as type">MSVC
1009       specific: <code class="computeroutput"><span class="special">...</span></code> in signatures treated
1010       as type</a>
1011 </h3></div></div></div>
1012 <p>
1013         MSVC (up to version 7.0) treats the ellipsis in a variable argument function
1014         (such as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">printf</span></code>) as a type. Therefore, it will accept
1015         the (incorrect in the current implementation) form:
1016       </p>
1017 <pre class="programlisting"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">printf</span><span class="special">,</span> <span class="string">"%s\n"</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">);</span>
1018 </pre>
1019 <p>
1020         and will reject the correct version:
1021       </p>
1022 <pre class="programlisting"><span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">printf</span><span class="special">,</span> <span class="string">"%s\n"</span><span class="special">,</span> <span class="identifier">_1</span><span class="special">);</span>
1023 </pre>
1024 </div>
1025 </div>
1026 <div class="section">
1027 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
1028 <a name="bind.interface"></a><a class="link" href="bind.html#bind.interface" title="Interface">Interface</a>
1029 </h2></div></div></div>
1030 <div class="section">
1031 <div class="titlepage"><div><div><h3 class="title">
1032 <a name="bind.interface.synopsys"></a><a class="link" href="bind.html#bind.interface.synopsys" title="Synopsis">Synopsis</a>
1033 </h3></div></div></div>
1034 <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
1035 <span class="special">{</span>
1036 <span class="comment">// no arguments</span>
1037
1038 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-1</em></span> <a class="link" href="bind.html#bind_1"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">);</span>
1039
1040 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-1-1</em></span> <a class="link" href="bind.html#bind_1_1"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">);</span>
1041
1042 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-2</em></span> <a class="link" href="bind.html#bind_2"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</span> <span class="special">(*</span><span class="identifier">f</span><span class="special">)</span> <span class="special">());</span>
1043
1044 <span class="comment">// one argument</span>
1045
1046 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-3</em></span> <a class="link" href="bind.html#bind_3"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">);</span>
1047
1048 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-3-1</em></span> <a class="link" href="bind.html#bind_3_1"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">);</span>
1049
1050 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-4</em></span> <a class="link" href="bind.html#bind_4"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</span> <span class="special">(*</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span><span class="identifier">B1</span><span class="special">),</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">);</span>
1051
1052 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-5</em></span> <a class="link" href="bind.html#bind_5"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</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="identifier">A1</span> <span class="identifier">a1</span><span class="special">);</span>
1053
1054 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-6</em></span> <a class="link" href="bind.html#bind_6"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</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">const</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">);</span>
1055
1056 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-6-1</em></span> <a class="link" href="bind.html#bind_6_1"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</span> <span class="identifier">T</span><span class="special">::*</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">);</span>
1057
1058 <span class="comment">// two arguments</span>
1059
1060 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-7</em></span> <a class="link" href="bind.html#bind_7"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">);</span>
1061
1062 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-7-1</em></span> <a class="link" href="bind.html#bind_7_1"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">);</span>
1063
1064 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">B2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-8</em></span> <a class="link" href="bind.html#bind_8"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</span> <span class="special">(*</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span><span class="identifier">B1</span><span class="special">,</span> <span class="identifier">B2</span><span class="special">),</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">);</span>
1065
1066 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-9</em></span> <a class="link" href="bind.html#bind_9"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</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="identifier">B1</span><span class="special">),</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">);</span>
1067
1068 <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-10</em></span> <a class="link" href="bind.html#bind_10"><code class="computeroutput"><span class="identifier">bind</span></code></a><span class="special">(</span><span class="identifier">R</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="identifier">B1</span><span class="special">)</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">);</span>
1069
1070 <span class="comment">// implementation defined number of additional overloads for more arguments</span>
1071 <span class="special">}</span>
1072
1073 <span class="keyword">namespace</span>
1074 <span class="special">{</span>
1075  <span class="emphasis"><em>unspecified-placeholder-type-1</em></span> <span class="identifier">_1</span><span class="special">;</span>
1076
1077  <span class="emphasis"><em>unspecified-placeholder-type-2</em></span> <span class="identifier">_2</span><span class="special">;</span>
1078
1079  <span class="emphasis"><em>unspecified-placeholder-type-3</em></span> <span class="identifier">_3</span><span class="special">;</span>
1080
1081 <span class="comment">// implementation defined number of additional placeholder definitions</span>
1082 <span class="special">}</span>
1083 </pre>
1084 </div>
1085 <div class="section">
1086 <div class="titlepage"><div><div><h3 class="title">
1087 <a name="bind.interface.common_requirements"></a><a class="link" href="bind.html#bind.interface.common_requirements" title="Common requirements">Common requirements</a>
1088 </h3></div></div></div>
1089 <p>
1090         All <span class="emphasis"><em>unspecified-N</em></span> types returned by <code class="computeroutput"><span class="identifier">bind</span></code>
1091         are <span class="emphasis"><em>CopyConstructible</em></span>. <span class="emphasis"><em>unspecified-N</em></span><code class="computeroutput"><span class="special">::</span><span class="identifier">result_type</span></code>
1092         is defined as the return type of <span class="emphasis"><em>unspecified-N</em></span><code class="computeroutput"><span class="special">::</span><span class="keyword">operator</span><span class="special">()</span></code>.
1093       </p>
1094 <p>
1095         All <span class="emphasis"><em>unspecified-placeholder-N</em></span> types are <span class="emphasis"><em>CopyConstructible</em></span>.
1096         Their copy constructors do not throw exceptions.
1097       </p>
1098 </div>
1099 <div class="section">
1100 <div class="titlepage"><div><div><h3 class="title">
1101 <a name="bind.interface.common_definitions"></a><a class="link" href="bind.html#bind.interface.common_definitions" title="Common definitions">Common definitions</a>
1102 </h3></div></div></div>
1103 <p>
1104         The function &#956;<code class="computeroutput"><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">v1</span><span class="special">,</span>
1105         <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code>, where <code class="computeroutput"><span class="identifier">m</span></code>
1106         is a nonnegative integer, is defined as:
1107       </p>
1108 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1109 <li class="listitem">
1110             <code class="computeroutput"><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code>,
1111             when <code class="computeroutput"><span class="identifier">x</span></code> is of type <a href="../../../../libs/core/doc/html/core/ref.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">reference_wrapper</span></code></a><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> for some type <code class="computeroutput"><span class="identifier">T</span></code>;
1112           </li>
1113 <li class="listitem">
1114             <code class="computeroutput"><span class="identifier">vk</span></code>, when <code class="computeroutput"><span class="identifier">x</span></code> is (a copy of) the placeholder <span class="emphasis"><em>_k</em></span>
1115             for some positive integer <span class="emphasis"><em>k</em></span>;
1116           </li>
1117 <li class="listitem">
1118             <code class="computeroutput"><span class="identifier">x</span><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code> when <code class="computeroutput"><span class="identifier">x</span></code>
1119             is (a copy of) a function object returned by <code class="computeroutput"><span class="identifier">bind</span></code>;
1120           </li>
1121 <li class="listitem">
1122             <code class="computeroutput"><span class="identifier">x</span></code> otherwise.
1123           </li>
1124 </ul></div>
1125 </div>
1126 <div class="section">
1127 <div class="titlepage"><div><div><h3 class="title">
1128 <a name="bind.interface.bind"></a><a class="link" href="bind.html#bind.interface.bind" title="bind"><code class="computeroutput"><span class="identifier">bind</span></code></a>
1129 </h3></div></div></div>
1130 <a name="bind_1"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-1</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">)</span>
1131 </pre>
1132 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1133 <li class="listitem">
1134             <span class="emphasis"><em>Returns:</em></span> A function object &#955; such that the
1135             expression &#955;<code class="computeroutput"><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code>
1136             is equivalent to <code class="computeroutput"><span class="identifier">f</span><span class="special">()</span></code>,
1137             implicitly converted to <code class="computeroutput"><span class="identifier">R</span></code>.
1138           </li>
1139 <li class="listitem">
1140             <span class="emphasis"><em>Throws:</em></span> Nothing unless the copy constructor of
1141             <code class="computeroutput"><span class="identifier">F</span></code> throws an exception.
1142           </li>
1143 </ul></div>
1144 <a name="bind_1_1"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-1-1</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">)</span>
1145 </pre>
1146 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1147 <li class="listitem">
1148             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">typename</span>
1149             <span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span><span class="special">,</span>
1150             <span class="identifier">F</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">)</span></code>.
1151           </li>
1152 <li class="listitem">
1153             <span class="emphasis"><em>Notes:</em></span> Implementations are allowed to infer the
1154             return type of <code class="computeroutput"><span class="identifier">f</span></code> via
1155             other means as an extension, without relying on the <code class="computeroutput"><span class="identifier">result_type</span></code>
1156             member.
1157           </li>
1158 </ul></div>
1159 <a name="bind_2"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-2</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</span> <span class="special">(*</span><span class="identifier">f</span><span class="special">)</span> <span class="special">())</span>
1160 </pre>
1161 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1162 <li class="listitem">
1163             <span class="emphasis"><em>Returns:</em></span> A function object &#955; such that the
1164             expression &#955;<code class="computeroutput"><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code>
1165             is equivalent to <code class="computeroutput"><span class="identifier">f</span><span class="special">()</span></code>.
1166           </li>
1167 <li class="listitem">
1168             <span class="emphasis"><em>Throws:</em></span> Nothing.
1169           </li>
1170 </ul></div>
1171 <a name="bind_3"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-3</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">)</span>
1172 </pre>
1173 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1174 <li class="listitem">
1175             <span class="emphasis"><em>Returns:</em></span> A function object &#955; such that the
1176             expression &#955;<code class="computeroutput"><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code>
1177             is equivalent to <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span></code>&#956;<code class="computeroutput"><span class="special">(</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">))</span></code>,
1178             implicitly converted to <code class="computeroutput"><span class="identifier">R</span></code>.
1179           </li>
1180 <li class="listitem">
1181             <span class="emphasis"><em>Throws:</em></span> Nothing unless the copy constructors of
1182             <code class="computeroutput"><span class="identifier">F</span></code> or <code class="computeroutput"><span class="identifier">A1</span></code>
1183             throw an exception.
1184           </li>
1185 </ul></div>
1186 <a name="bind_3_1"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-3-1</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">)</span>
1187 </pre>
1188 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1189 <li class="listitem">
1190             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">typename</span>
1191             <span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span><span class="special">,</span>
1192             <span class="identifier">F</span><span class="special">,</span>
1193             <span class="identifier">A1</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a1</span><span class="special">)</span></code>.
1194           </li>
1195 <li class="listitem">
1196             <span class="emphasis"><em>Notes:</em></span> Implementations are allowed to infer the
1197             return type of <code class="computeroutput"><span class="identifier">f</span></code> via
1198             other means as an extension, without relying on the <code class="computeroutput"><span class="identifier">result_type</span></code>
1199             member.
1200           </li>
1201 </ul></div>
1202 <a name="bind_4"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-4</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</span> <span class="special">(*</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span><span class="identifier">B1</span><span class="special">),</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">)</span>
1203 </pre>
1204 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1205 <li class="listitem">
1206             <span class="emphasis"><em>Returns:</em></span> A function object &#955; such that the
1207             expression &#955;<code class="computeroutput"><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code>
1208             is equivalent to <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span></code>&#956;<code class="computeroutput"><span class="special">(</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">))</span></code>.
1209           </li>
1210 <li class="listitem">
1211             <span class="emphasis"><em>Throws:</em></span> Nothing unless the copy constructor of
1212             <code class="computeroutput"><span class="identifier">A1</span></code> throws an exception.
1213           </li>
1214 </ul></div>
1215 <a name="bind_5"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-5</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</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="identifier">A1</span> <span class="identifier">a1</span><span class="special">)</span>
1216 </pre>
1217 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1218             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span></code><a href="../../../../libs/bind/mem_fn.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mem_fn</span></code></a><code class="computeroutput"><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a1</span><span class="special">)</span></code>.
1219           </li></ul></div>
1220 <a name="bind_6"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-6</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</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">const</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">)</span>
1221 </pre>
1222 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1223             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span></code><a href="../../../../libs/bind/mem_fn.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mem_fn</span></code></a><code class="computeroutput"><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a1</span><span class="special">)</span></code>.
1224           </li></ul></div>
1225 <a name="bind_6_1"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">A1</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-6-1</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</span> <span class="identifier">T</span><span class="special">::*</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">)</span>
1226 </pre>
1227 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1228             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span></code><a href="../../../../libs/bind/mem_fn.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mem_fn</span></code></a><code class="computeroutput"><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a1</span><span class="special">)</span></code>.
1229           </li></ul></div>
1230 <a name="bind_7"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-7</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">)</span>
1231 </pre>
1232 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1233 <li class="listitem">
1234             <span class="emphasis"><em>Returns:</em></span> A function object &#955; such that the
1235             expression &#955;<code class="computeroutput"><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code>
1236             is equivalent to <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span></code>&#956;<code class="computeroutput"><span class="special">(</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">),</span> </code>&#956;<code class="computeroutput"><span class="special">(</span><span class="identifier">a2</span><span class="special">,</span> <span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">))</span></code>,
1237             implicitly converted to <code class="computeroutput"><span class="identifier">R</span></code>.
1238           </li>
1239 <li class="listitem">
1240             <span class="emphasis"><em>Throws:</em></span> Nothing unless the copy constructors of
1241             <code class="computeroutput"><span class="identifier">F</span></code>, <code class="computeroutput"><span class="identifier">A1</span></code>
1242             or <code class="computeroutput"><span class="identifier">A2</span></code> throw an exception.
1243           </li>
1244 </ul></div>
1245 <a name="bind_7_1"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">F</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-7-1</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">F</span> <span class="identifier">f</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">)</span>
1246 </pre>
1247 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1248 <li class="listitem">
1249             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">typename</span>
1250             <span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span><span class="special">,</span>
1251             <span class="identifier">F</span><span class="special">,</span>
1252             <span class="identifier">A1</span><span class="special">,</span>
1253             <span class="identifier">A2</span><span class="special">&gt;(</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">)</span></code>.
1254           </li>
1255 <li class="listitem">
1256             <span class="emphasis"><em>Notes:</em></span> Implementations are allowed to infer the
1257             return type of <code class="computeroutput"><span class="identifier">f</span></code> via
1258             other means as an extension, without relying on the <code class="computeroutput"><span class="identifier">result_type</span></code>
1259             member.
1260           </li>
1261 </ul></div>
1262 <a name="bind_8"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">B2</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-8</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</span> <span class="special">(*</span><span class="identifier">f</span><span class="special">)</span> <span class="special">(</span><span class="identifier">B1</span><span class="special">,</span> <span class="identifier">B2</span><span class="special">),</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">)</span>
1263 </pre>
1264 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1265 <li class="listitem">
1266             <span class="emphasis"><em>Returns:</em></span> A function object &#955; such that the
1267             expression &#955;<code class="computeroutput"><span class="special">(</span><span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">)</span></code>
1268             is equivalent to <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span></code>&#956;<code class="computeroutput"><span class="special">(</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">),</span> </code>&#956;<code class="computeroutput"><span class="special">(</span><span class="identifier">a2</span><span class="special">,</span> <span class="identifier">v1</span><span class="special">,</span> <span class="identifier">v2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">vm</span><span class="special">))</span></code>.
1269           </li>
1270 <li class="listitem">
1271             <span class="emphasis"><em>Throws:</em></span> Nothing unless the copy constructors of
1272             <code class="computeroutput"><span class="identifier">A1</span></code> or <code class="computeroutput"><span class="identifier">A2</span></code>
1273             throw an exception.
1274           </li>
1275 </ul></div>
1276 <a name="bind_9"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-9</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</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="identifier">B1</span><span class="special">),</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">)</span>
1277 </pre>
1278 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1279             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span></code><a href="../../../../libs/bind/mem_fn.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mem_fn</span></code></a><code class="computeroutput"><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">)</span></code>.
1280           </li></ul></div>
1281 <a name="bind_10"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">R</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">B1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A2</span><span class="special">&gt;</span> <span class="emphasis"><em>unspecified-10</em></span> <span class="identifier">bind</span><span class="special">(</span><span class="identifier">R</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="identifier">B1</span><span class="special">)</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">A1</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">A2</span> <span class="identifier">a2</span><span class="special">)</span>
1282 </pre>
1283 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
1284             <span class="emphasis"><em>Effects:</em></span> Equivalent to <code class="computeroutput"><span class="identifier">bind</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(</span></code><a href="../../../../libs/bind/mem_fn.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mem_fn</span></code></a><code class="computeroutput"><span class="special">(</span><span class="identifier">f</span><span class="special">),</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">)</span></code>.
1285           </li></ul></div>
1286 </div>
1287 <div class="section">
1288 <div class="titlepage"><div><div><h3 class="title">
1289 <a name="bind.interface.additional_overloads"></a><a class="link" href="bind.html#bind.interface.additional_overloads" title="Additional overloads">Additional overloads</a>
1290 </h3></div></div></div>
1291 <p>
1292         Implementations are allowed to provide additional <code class="computeroutput"><span class="identifier">bind</span></code>
1293         overloads in order to support more arguments or different function pointer
1294         variations.
1295       </p>
1296 </div>
1297 </div>
1298 <div class="section">
1299 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
1300 <a name="bind.implementation"></a><a class="link" href="bind.html#bind.implementation" title="Implementation">Implementation</a>
1301 </h2></div></div></div>
1302 <div class="section">
1303 <div class="titlepage"><div><div><h3 class="title">
1304 <a name="bind.implementation.files"></a><a class="link" href="bind.html#bind.implementation.files" title="Files">Files</a>
1305 </h3></div></div></div>
1306 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1307 <li class="listitem">
1308             <a href="../../../../boost/bind.hpp" target="_top">boost/bind.hpp</a> (main
1309             header)
1310           </li>
1311 <li class="listitem">
1312             <a href="../../../../boost/bind/bind_cc.hpp" target="_top">boost/bind/bind_cc.hpp</a>
1313             (used by <code class="computeroutput"><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span></code>, do not include directly)
1314           </li>
1315 <li class="listitem">
1316             <a href="../../../../boost/bind/bind_mf_cc.hpp" target="_top">boost/bind/bind_mf_cc.hpp</a>
1317             (used by <code class="computeroutput"><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span></code>, do not include directly)
1318           </li>
1319 <li class="listitem">
1320             <a href="../../../../boost/bind/bind_template.hpp" target="_top">boost/bind/bind_template.hpp</a>
1321             (used by <code class="computeroutput"><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span></code>, do not include directly)
1322           </li>
1323 <li class="listitem">
1324             <a href="../../../../boost/bind/arg.hpp" target="_top">boost/bind/arg.hpp</a>
1325             (defines the type of the placeholder arguments)
1326           </li>
1327 <li class="listitem">
1328             <a href="../../../../boost/bind/placeholders.hpp" target="_top">boost/bind/placeholders.hpp</a>
1329             (defines the <code class="computeroutput"><span class="identifier">_1</span></code>, <code class="computeroutput"><span class="identifier">_2</span></code>, ... <code class="computeroutput"><span class="identifier">_9</span></code>
1330             placeholders)
1331           </li>
1332 <li class="listitem">
1333             <a href="../../../../boost/bind/apply.hpp" target="_top">boost/bind/apply.hpp</a>
1334             (<code class="computeroutput"><span class="identifier">apply</span></code> helper function
1335             object)
1336           </li>
1337 <li class="listitem">
1338             <a href="../../../../boost/bind/protect.hpp" target="_top">boost/bind/protect.hpp</a>
1339             (<code class="computeroutput"><span class="identifier">protect</span></code> helper function)
1340           </li>
1341 <li class="listitem">
1342             <a href="../../../../boost/bind/make_adaptable.hpp" target="_top">boost/bind/make_adaptable.hpp</a>
1343             (<code class="computeroutput"><span class="identifier">make_adaptable</span></code> helper
1344             function)
1345           </li>
1346 <li class="listitem">
1347             <a href="../../test/bind_test.cpp" target="_top">libs/bind/test/bind_test.cpp</a>
1348             (test)
1349           </li>
1350 <li class="listitem">
1351             <a href="../../bind_as_compose.cpp" target="_top">libs/bind/bind_as_compose.cpp</a>
1352             (function composition example)
1353           </li>
1354 <li class="listitem">
1355             <a href="../../bind_visitor.cpp" target="_top">libs/bind/bind_visitor.cpp</a>
1356             (visitor example)
1357           </li>
1358 <li class="listitem">
1359             <a href="../../test/bind_stdcall_test.cpp" target="_top">libs/bind/test/bind_stdcall_test.cpp</a>
1360             (test with <code class="computeroutput"><span class="identifier">__stdcall</span></code>
1361             functions)
1362           </li>
1363 <li class="listitem">
1364             <a href="../../test/bind_stdcall_mf_test.cpp" target="_top">libs/bind/test/bind_stdcall_mf_test.cpp</a>
1365             (test with <code class="computeroutput"><span class="identifier">__stdcall</span></code>
1366             member functions)
1367           </li>
1368 <li class="listitem">
1369             <a href="../../test/bind_fastcall_test.cpp" target="_top">libs/bind/test/bind_fastcall_test.</a>
1370             (test with <code class="computeroutput"><span class="identifier">__fastcall</span></code>
1371             functions)
1372           </li>
1373 <li class="listitem">
1374             <a href="../../test/bind_fastcall_mf_test.cpp" target="_top">libs/bind/test/bind_fastcall_mf_test.cpp</a>
1375             (test with <code class="computeroutput"><span class="identifier">__fastcall</span></code>
1376             member functions)
1377           </li>
1378 </ul></div>
1379 </div>
1380 <div class="section">
1381 <div class="titlepage"><div><div><h3 class="title">
1382 <a name="bind.implementation.dependencies"></a><a class="link" href="bind.html#bind.implementation.dependencies" title="Dependencies">Dependencies</a>
1383 </h3></div></div></div>
1384 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1385 <li class="listitem">
1386             <a href="../../../../libs/config/config.htm" target="_top">Boost.Config</a>
1387           </li>
1388 <li class="listitem">
1389             <a href="../../../../libs/core/doc/html/core/ref.html" target="_top">boost/ref.hpp</a>
1390           </li>
1391 <li class="listitem">
1392             <a href="../../../../libs/bind/mem_fn.html" target="_top">boost/mem_fn.hpp</a>
1393           </li>
1394 <li class="listitem">
1395             <a href="../../../../boost/type.hpp" target="_top">boost/type.hpp</a>
1396           </li>
1397 </ul></div>
1398 </div>
1399 <div class="section">
1400 <div class="titlepage"><div><div><h3 class="title">
1401 <a name="bind.implementation.number_of_arguments"></a><a class="link" href="bind.html#bind.implementation.number_of_arguments" title="Number of Arguments">Number of Arguments</a>
1402 </h3></div></div></div>
1403 <p>
1404         This implementation supports function objects with up to nine arguments.
1405         This is an implementation detail, not an inherent limitation of the design.
1406       </p>
1407 </div>
1408 <div class="section">
1409 <div class="titlepage"><div><div><h3 class="title">
1410 <a name="bind.implementation.stdcall"></a><a class="link" href="bind.html#bind.implementation.stdcall" title="__stdcall, __cdecl, __fastcall, and pascal Support"><code class="computeroutput"><span class="identifier">__stdcall</span></code>,
1411       <code class="computeroutput"><span class="identifier">__cdecl</span></code>, <code class="computeroutput"><span class="identifier">__fastcall</span></code>,
1412       and <code class="computeroutput"><span class="identifier">pascal</span></code> Support</a>
1413 </h3></div></div></div>
1414 <p>
1415         Some platforms allow several types of (member) functions that differ by their
1416         calling convention (the rules by which the function is invoked: how are arguments
1417         passed, how is the return value handled, and who cleans up the stack - if
1418         any.)
1419       </p>
1420 <p>
1421         For example, Windows API functions and COM interface member functions use
1422         a calling convention known as <code class="computeroutput"><span class="identifier">__stdcall</span></code>.
1423         Borland VCL components use <code class="computeroutput"><span class="identifier">__fastcall</span></code>.
1424         Mac toolbox functions use a <code class="computeroutput"><span class="identifier">pascal</span></code>
1425         calling convention.
1426       </p>
1427 <p>
1428         To use <code class="computeroutput"><span class="identifier">bind</span></code> with <code class="computeroutput"><span class="identifier">__stdcall</span></code> functions, <code class="computeroutput"><span class="preprocessor">#define</span></code>
1429         the macro <code class="computeroutput"><span class="identifier">BOOST_BIND_ENABLE_STDCALL</span></code>
1430         before including <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
1431       </p>
1432 <p>
1433         To use <code class="computeroutput"><span class="identifier">bind</span></code> with <code class="computeroutput"><span class="identifier">__stdcall</span></code> member functions, <code class="computeroutput"><span class="preprocessor">#define</span></code> the macro <code class="computeroutput"><span class="identifier">BOOST_MEM_FN_ENABLE_STDCALL</span></code>
1434         before including <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
1435       </p>
1436 <p>
1437         To use <code class="computeroutput"><span class="identifier">bind</span></code> with <code class="computeroutput"><span class="identifier">__fastcall</span></code> functions, <code class="computeroutput"><span class="preprocessor">#define</span></code>
1438         the macro <code class="computeroutput"><span class="identifier">BOOST_BIND_ENABLE_FASTCALL</span></code>
1439         before including <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
1440       </p>
1441 <p>
1442         To use <code class="computeroutput"><span class="identifier">bind</span></code> with <code class="computeroutput"><span class="identifier">__fastcall</span></code> member functions, <code class="computeroutput"><span class="preprocessor">#define</span></code> the macro <code class="computeroutput"><span class="identifier">BOOST_MEM_FN_ENABLE_FASTCALL</span></code>
1443         before including <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
1444       </p>
1445 <p>
1446         To use <code class="computeroutput"><span class="identifier">bind</span></code> with <code class="computeroutput"><span class="identifier">pascal</span></code> functions, <code class="computeroutput"><span class="preprocessor">#define</span></code>
1447         the macro <code class="computeroutput"><span class="identifier">BOOST_BIND_ENABLE_PASCAL</span></code>
1448         before including <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
1449       </p>
1450 <p>
1451         To use <code class="computeroutput"><span class="identifier">bind</span></code> with <code class="computeroutput"><span class="identifier">__cdecl</span></code> member functions, <code class="computeroutput"><span class="preprocessor">#define</span></code> the macro <code class="computeroutput"><span class="identifier">BOOST_MEM_FN_ENABLE_CDECL</span></code>
1452         before including <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>.
1453       </p>
1454 <p>
1455         <span class="bold"><strong>It is best to define these macros in the project options,
1456         via <code class="computeroutput"><span class="special">-</span><span class="identifier">D</span></code>
1457         on the command line, or as the first line in the translation unit (.cpp file)
1458         where <code class="computeroutput"><span class="identifier">bind</span></code> is used.</strong></span>
1459         Not following this rule can lead to obscure errors when a header includes
1460         <code class="computeroutput"><span class="identifier">bind</span><span class="special">.</span><span class="identifier">hpp</span></code> before the macro has been defined.
1461       </p>
1462 <p>
1463         <span class="emphasis"><em>[Note:</em></span> this is a non-portable extension. It is not part
1464         of the interface.<span class="emphasis"><em>]</em></span>
1465       </p>
1466 <p>
1467         <span class="emphasis"><em>[Note:</em></span> Some compilers provide only minimal support for
1468         the <code class="computeroutput"><span class="identifier">__stdcall</span></code> keyword.<span class="emphasis"><em>]</em></span>
1469       </p>
1470 </div>
1471 <div class="section">
1472 <div class="titlepage"><div><div><h3 class="title">
1473 <a name="bind.implementation.visit_each_support"></a><a class="link" href="bind.html#bind.implementation.visit_each_support" title="visit_each support"><code class="computeroutput"><span class="identifier">visit_each</span></code> support</a>
1474 </h3></div></div></div>
1475 <p>
1476         Function objects returned by <code class="computeroutput"><span class="identifier">bind</span></code>
1477         support the experimental and undocumented, as of yet, <code class="computeroutput"><span class="identifier">visit_each</span></code>
1478         enumeration interface.
1479       </p>
1480 <p>
1481         See <a href="../../bind_visitor.cpp" target="_top">bind_visitor.cpp</a> for an example.
1482       </p>
1483 </div>
1484 </div>
1485 <div class="section">
1486 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
1487 <a name="bind.acknowledgements"></a><a class="link" href="bind.html#bind.acknowledgements" title="Acknowledgements">Acknowledgements</a>
1488 </h2></div></div></div>
1489 <p>
1490       Earlier efforts that have influenced the library design:
1491     </p>
1492 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
1493 <li class="listitem">
1494           The <a href="http://staff.cs.utu.fi/BL/" target="_top">Binder Library</a> by Jaakko
1495           J&#228;rvi;
1496         </li>
1497 <li class="listitem">
1498           The <a href="../../../../libs/lambda/index.html" target="_top">Lambda Library</a> (now
1499           part of Boost) by Jaakko J&#228;rvi and Gary Powell (the successor to the
1500           Binder Library);
1501         </li>
1502 <li class="listitem">
1503           <a href="http://more.sourceforge.net/" target="_top">Extensions to the STL</a>
1504           by Petter Urkedal.
1505         </li>
1506 </ul></div>
1507 <p>
1508       Doug Gregor suggested that a visitor mechanism would allow <code class="computeroutput"><span class="identifier">bind</span></code>
1509       to interoperate with a signal/slot library.
1510     </p>
1511 <p>
1512       John Maddock fixed a MSVC-specific conflict between <code class="computeroutput"><span class="identifier">bind</span></code>
1513       and the <a href="../../../../libs/type_traits/index.html" target="_top">type traits library</a>.
1514     </p>
1515 <p>
1516       Numerous improvements were suggested during the formal review period by Ross
1517       Smith, Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was
1518       Darin Adler.
1519     </p>
1520 <p>
1521       The precise semantics of <code class="computeroutput"><span class="identifier">bind</span></code>
1522       were refined in discussions with Jaakko J&#228;rvi.
1523     </p>
1524 <p>
1525       Dave Abrahams fixed a MSVC-specific conflict between <code class="computeroutput"><span class="identifier">bind</span></code>
1526       and the <a href="../../../../libs/utility/iterator_adaptors.htm" target="_top">iterator adaptors
1527       library</a>.
1528     </p>
1529 <p>
1530       Dave Abrahams modified <code class="computeroutput"><span class="identifier">bind</span></code>
1531       and <code class="computeroutput"><span class="identifier">mem_fn</span></code> to support <code class="computeroutput"><span class="keyword">void</span></code> returns on deficient compilers.
1532     </p>
1533 <p>
1534       Mac Murrett contributed the "pascal" support enabled by <code class="computeroutput"><span class="identifier">BOOST_BIND_ENABLE_PASCAL</span></code>.
1535     </p>
1536 <p>
1537       The alternative <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">type</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;(),</span> <span class="identifier">f</span><span class="special">,</span> <span class="special">...)</span></code>
1538       syntax was inspired by a discussion with Dave Abrahams and Joel de Guzman.
1539     </p>
1540 <p>
1541       This documentation was ported to Quickbook by Agust&#237;n Berg&#233;.
1542     </p>
1543 </div>
1544 </div>
1545 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
1546 <td align="left"><p><small>Last revised: December 10, 2019 at 00:24:16 GMT</small></p></td>
1547 <td align="right"><div class="copyright-footer"></div></td>
1548 </tr></table>
1549 <hr>
1550 <div class="spirit-nav"></div>
1551 </body>
1552 </html>