Gitiles
Code Review Sign In
realtimeroboticsgroup.org / RealtimeRoboticsGroup / test / ce4aa8d0d4deafe13ed4364525f69acdd071474b / . / doc / html / bind.html
blob: 5f35c5d82f62273ef8a391c434a48d3ea278f9ac [file] [log] [blame]
Brian Silvermance4aa8d2018-08-04 23:36:03 -0700[diff] [blame^]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.78.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="http://www.sgi.com/tech/stl/UnaryFunction.html" target="_top"><span class="emphasis"><em>Unary
904 Function</em></span></a> or <a href="http://www.sgi.com/tech/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: July 07, 2017 at 11:19:28 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>