<dt><spanclass="section"><ahref="bind.html#bind.faq.why_doesn_t_this_compile">Why doesn't this compile?</a></span></dt>
<dt><spanclass="section"><ahref="bind.html#bind.faq.why_does_this_compile_it_should_">Why does this
compile? It should not.</a></span></dt>
<dt><spanclass="section"><ahref="bind.html#bind.faq.Q_forms">What is the difference between <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code> and
use of <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code></a></span></dt>
use of <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code></a></span></dt>
<dt><spanclass="section"><ahref="bind.html#bind.troubleshooting.const_in_signatures"><codeclass="computeroutput"><spanclass="keyword">const</span></code> in signatures</a></span></dt>
<codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span></code> is a generalization of the standard
functions <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">bind1st</span></code> and <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">bind2nd</span></code>.
It supports arbitrary function objects, functions, function pointers, and member
function pointers, and is able to bind any argument to a specific value or
route input arguments into arbitrary positions. <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
does not place any requirements on the function object; in particular, it does
not need the <codeclass="computeroutput"><spanclass="identifier">result_type</span></code>,
<codeclass="computeroutput"><spanclass="identifier">first_argument_type</span></code> and <codeclass="computeroutput"><spanclass="identifier">second_argument_type</span></code> standard typedefs.
</p>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.purpose.using_bind_with_functions_and_fu"></a><aclass="link"href="bind.html#bind.purpose.using_bind_with_functions_and_fu"title="Using bind with functions and function pointers">Using
will produce a "nullary" function object that takes no arguments
and returns <codeclass="computeroutput"><spanclass="identifier">f</span><spanclass="special">(</span><spanclass="number">1</span><spanclass="special">,</span><spanclass="number">2</span><spanclass="special">)</span></code>. Similarly, <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">g</span><spanclass="special">,</span>
<spanclass="number">1</span><spanclass="special">,</span><spanclass="number">2</span><spanclass="special">,</span><spanclass="number">3</span><spanclass="special">)()</span></code> is equivalent <codeclass="computeroutput"><spanclass="identifier">to</span>
It is possible to selectively bind only some of the arguments. <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">,</span>
<spanclass="number">5</span><spanclass="special">)(</span><spanclass="identifier">x</span><spanclass="special">)</span></code> is equivalent
to <codeclass="computeroutput"><spanclass="identifier">f</span><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">,</span><spanclass="number">5</span><spanclass="special">)</span></code>; here <codeclass="computeroutput"><spanclass="identifier">_1</span></code>
is a <spanclass="emphasis"><em>placeholder</em></span> argument that means "substitute
with the first input argument."
</p>
<p>
For comparison, here is the same operation expressed with the standard library
Note that, in the last example, the function object produced by <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">g</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">,</span>
<spanclass="identifier">_1</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">)</span></code> does
not contain references to any arguments beyond the first, but it can still
be used with more than one argument. Any extra arguments are silently ignored,
just like the first and the second argument are ignored in the third example.
</p>
<p>
The arguments that <codeclass="computeroutput"><spanclass="identifier">bind</span></code> takes
are copied and held internally by the returned function object. For example,
a copy of the value of <codeclass="computeroutput"><spanclass="identifier">i</span></code>
is stored into the function object. <ahref="../../../../libs/core/doc/html/core/ref.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">ref</span></code></a> and <ahref="../../../../libs/core/doc/html/core/ref.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">cref</span></code></a> can be used to make the function
object store a reference to an object, rather than a copy:
<aname="bind.purpose.with_function_objects"></a><aclass="link"href="bind.html#bind.purpose.with_function_objects"title="Using bind with function objects">Using bind with function
objects</a>
</h3></div></div></div>
<p>
<codeclass="computeroutput"><spanclass="identifier">bind</span></code> is not limited to functions;
it accepts arbitrary function objects. In the general case, the return type
of the generated function object's <codeclass="computeroutput"><spanclass="keyword">operator</span><spanclass="special">()</span></code> has to be specified explicitly (without
a <codeclass="computeroutput"><spanclass="identifier">typeof</span></code> operator the return
<spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="keyword">int</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">)(</span><spanclass="identifier">x</span><spanclass="special">);</span><spanclass="comment">// f(x, x), i.e. zero</span>
</pre>
<p>
Some compilers have trouble with the <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
syntax. For portability reasons, an alternative way to express the above
<spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">less</span><spanclass="special"><</span><spanclass="keyword">int</span><spanclass="special">>(),</span><spanclass="identifier">_1</span><spanclass="special">,</span><spanclass="number">9</span><spanclass="special">)(</span><spanclass="identifier">x</span><spanclass="special">);</span><spanclass="comment">// x < 9</span>
</pre>
<p>
<spanclass="emphasis"><em>[Note:</em></span> the ability to omit the return type is not available
on all compilers.<spanclass="emphasis"><em>]</em></span>
</p>
<p>
By default, <codeclass="computeroutput"><spanclass="identifier">bind</span></code> makes a
copy of the provided function object. <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">ref</span></code> and
<codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">cref</span></code> can be used to make it store a reference
to the function object, rather than a copy. This can be useful when the function
object is non-copyable, expensive to copy, or contains state; of course,
in this case the programmer is expected to ensure that the function object
<aname="bind.purpose.using_bind_with_pointers_to_memb"></a><aclass="link"href="bind.html#bind.purpose.using_bind_with_pointers_to_memb"title="Using bind with pointers to members">Using
bind with pointers to members</a>
</h3></div></div></div>
<p>
Pointers to member functions and pointers to data members are not function
objects, because they do not support <codeclass="computeroutput"><spanclass="keyword">operator</span><spanclass="special">()</span></code>. For convenience, <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
accepts member pointers as its first argument, and the behavior is as if
where <codeclass="computeroutput"><spanclass="identifier">R</span></code> is the return type
of <codeclass="computeroutput"><spanclass="identifier">X</span><spanclass="special">::</span><spanclass="identifier">f</span></code> (for member functions) or the type of
creates function objects that are able to accept a pointer, a reference,
or a smart pointer to an object as its first argument; for additional information,
see the <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code><ahref="../../../../libs/bind/mem_fn.html"target="_top">documentation</a>.<spanclass="emphasis"><em>]</em></span>
<spanclass="identifier">bind</span><spanclass="special">(&</span><spanclass="identifier">X</span><spanclass="special">::</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">x</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">)(</span><spanclass="identifier">i</span><spanclass="special">);</span><spanclass="comment">// (internal copy of x).f(i)</span>
<spanclass="identifier">bind</span><spanclass="special">(&</span><spanclass="identifier">X</span><spanclass="special">::</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">p</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">)(</span><spanclass="identifier">i</span><spanclass="special">);</span><spanclass="comment">// (internal copy of p)->f(i)</span>
</pre>
<p>
The last two examples are interesting in that they produce "self-contained"
function objects. <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(&</span><spanclass="identifier">X</span><spanclass="special">::</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">x</span><spanclass="special">,</span>
stores a copy of <codeclass="computeroutput"><spanclass="identifier">x</span></code>. <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(&</span><spanclass="identifier">X</span><spanclass="special">::</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">p</span><spanclass="special">,</span>
<codeclass="computeroutput"><spanclass="identifier">p</span></code> is a <ahref="../../../../libs/smart_ptr/doc/html/smart_ptr.html#shared_ptr"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">shared_ptr</span></code></a>, the function object
retains a reference to its instance of <codeclass="computeroutput"><spanclass="identifier">X</span></code>
and will remain valid even when <codeclass="computeroutput"><spanclass="identifier">p</span></code>
goes out of scope or is <codeclass="computeroutput"><spanclass="identifier">reset</span><spanclass="special">()</span></code>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.purpose.using_nested_binds_for_function_"></a><aclass="link"href="bind.html#bind.purpose.using_nested_binds_for_function_"title="Using nested binds for function composition">Using
nested binds for function composition</a>
</h3></div></div></div>
<p>
Some of the arguments passed to <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
may be nested <spanclass="emphasis"><em>bind expressions</em></span> themselves:
The inner <spanclass="emphasis"><em>bind expressions</em></span> are evaluated, in unspecified
order, before the outer <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
when the function object is called; the results of the evaluation are then
substituted in their place when the outer <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
is evaluated. In the example above, when the function object is called with
the argument list <codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">)</span></code>, <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">g</span><spanclass="special">,</span>
<spanclass="identifier">_1</span><spanclass="special">)(</span><spanclass="identifier">x</span><spanclass="special">)</span></code> is evaluated
first, yielding <codeclass="computeroutput"><spanclass="identifier">g</span><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">)</span></code>, and
then <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">g</span><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">))(</span><spanclass="identifier">x</span><spanclass="special">)</span></code> is evaluated,
yielding the final result <codeclass="computeroutput"><spanclass="identifier">f</span><spanclass="special">(</span><spanclass="identifier">g</span><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">))</span></code>.
</p>
<p>
This feature of <codeclass="computeroutput"><spanclass="identifier">bind</span></code> can
be used to perform function composition. See <ahref="../../bind_as_compose.cpp"target="_top">bind_as_compose.cpp</a>
for an example that demonstrates how to use <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
to achieve similar functionality to <ahref="http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm"target="_top">Boost.Compose</a>.
</p>
<p>
Note that the first argument - the bound function object - is not evaluated,
even when it's a function object that is produced by <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
or a <spanclass="emphasis"><em>placeholder</em></span> argument, so the example below does
The desired effect can be achieved via a helper function object <codeclass="computeroutput"><spanclass="identifier">apply</span></code> that applies its first argument,
as a function object, to the rest of its argument list. For convenience,
an implementation of <codeclass="computeroutput"><spanclass="identifier">apply</span></code>
is provided in the <ahref="../../../../boost/bind/apply.hpp"target="_top">apply.hpp</a>
header file. Here is how the modified version of the previous example looks
Although the first argument is, by default, not evaluated, all other arguments
are. Sometimes it is necessary not to evaluate arguments subsequent to the
first, even when they are nested <spanclass="emphasis"><em>bind subexpressions</em></span>.
This can be achieved with the help of another function object, <codeclass="computeroutput"><spanclass="identifier">protect</span></code>, that masks the type so that <codeclass="computeroutput"><spanclass="identifier">bind</span></code> does not recognize and evaluate it.
When called, protect simply forwards the argument list to the other function
object unmodified.
</p>
<p>
The header <ahref="../../../../boost/bind/protect.hpp"target="_top">protect.hpp</a>
contains an implementation of <codeclass="computeroutput"><spanclass="identifier">protect</span></code>.
To <codeclass="computeroutput"><spanclass="identifier">protect</span></code> a bind function
object from evaluation, use <codeclass="computeroutput"><spanclass="identifier">protect</span><spanclass="special">(</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...))</span></code>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.purpose.overloaded_operators_new_in_boos"></a><aclass="link"href="bind.html#bind.purpose.overloaded_operators_new_in_boos"title="Overloaded operators (new in Boost 1.33)">Overloaded
operators (new in Boost 1.33)</a>
</h3></div></div></div>
<p>
For convenience, the function objects produced by <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
overload the logical not operator <codeclass="computeroutput"><spanclass="special">!</span></code>
and the relational and logical operators <codeclass="computeroutput"><spanclass="special">==,</span>
<spanclass="special">...)</span></code> is equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">logical_not</span><spanclass="special">(),</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span>
<spanclass="special">...))</span></code>, where <codeclass="computeroutput"><spanclass="identifier">logical_not</span></code>
is a function object that takes one argument <codeclass="computeroutput"><spanclass="identifier">x</span></code>
and returns <codeclass="computeroutput"><spanclass="special">!</span><spanclass="identifier">x</span></code>.
where <spanclass="underline">op</span> is a relational or logical
operator, is equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">relation</span><spanclass="special">(),</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span>
<spanclass="special">...),</span><spanclass="identifier">x</span><spanclass="special">)</span></code>, where <codeclass="computeroutput"><spanclass="identifier">relation</span></code>
is a function object that takes two arguments <codeclass="computeroutput"><spanclass="identifier">a</span></code>
and <codeclass="computeroutput"><spanclass="identifier">b</span></code> and returns <codeclass="computeroutput"><spanclass="identifier">a</span><spanclass="identifier">op</span><spanclass="identifier">b</span></code>.
</p>
<p>
What this means in practice is that you can conveniently negate the result
of <codeclass="computeroutput"><spanclass="identifier">bind</span></code>:
or against another <spanclass="emphasis"><em>bind expression</em></span>:
</p>
<preclass="programlisting"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">sort</span><spanclass="special">(</span><spanclass="identifier">first</span><spanclass="special">,</span><spanclass="identifier">last</span><spanclass="special">,</span><spanclass="identifier">bind</span><spanclass="special">(&</span><spanclass="identifier">X</span><spanclass="special">::</span><spanclass="identifier">name</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">)</span><spanclass="special"><</span><spanclass="identifier">bind</span><spanclass="special">(&</span><spanclass="identifier">X</span><spanclass="special">::</span><spanclass="identifier">name</span><spanclass="special">,</span><spanclass="identifier">_2</span><spanclass="special">));</span><spanclass="comment">// sort by name</span>
<aname="bind.examples.using_bind_with_standard_algorit"></a><aclass="link"href="bind.html#bind.examples.using_bind_with_standard_algorit"title="Using bind with standard algorithms">Using
<aname="bind.examples.using_bind_with_boost_function"></a><aclass="link"href="bind.html#bind.examples.using_bind_with_boost_function"title="Using bind with Boost.Function">Using bind
<aname="bind.faq.why_doesn_t_this_compile"></a><aclass="link"href="bind.html#bind.faq.why_doesn_t_this_compile"title="Why doesn't this compile?">Why doesn't this compile?</a>
</h3></div></div></div>
<p>
See the dedicated <aclass="link"href="bind.html#bind.troubleshooting"title="Troubleshooting">Troubleshooting section</a>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.faq.why_does_this_compile_it_should_"></a><aclass="link"href="bind.html#bind.faq.why_does_this_compile_it_should_"title="Why does this compile? It should not.">Why does this
compile? It should not.</a>
</h3></div></div></div>
<p>
Probably because you used the general <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
to not "inspect" f to detect arity and return type errors.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.faq.Q_forms"></a><aclass="link"href="bind.html#bind.faq.Q_forms"title="What is the difference between bind(f, ...) and bind<R>(f, ...)?">What is the difference between <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code> and
The first form instructs <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
to inspect the type of <codeclass="computeroutput"><spanclass="identifier">f</span></code>
in order to determine its arity (number of arguments) and return type. Arity
errors will be detected at "bind time". This syntax, of course,
places some requirements on <codeclass="computeroutput"><spanclass="identifier">f</span></code>.
It must be a function, function pointer, member function pointer, or a function
object that defines a nested type named <codeclass="computeroutput"><spanclass="identifier">result_type</span></code>;
in short, it must be something that <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
can recognize.
</p>
<p>
The second form instructs <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
to not attempt to recognize the type of <codeclass="computeroutput"><spanclass="identifier">f</span></code>.
It is generally used with function objects that do not, or cannot, expose
<codeclass="computeroutput"><spanclass="identifier">result_type</span></code>, but it can also
be used with nonstandard functions. For example, the current implementation
does not automatically recognize variable-argument functions like <codeclass="computeroutput"><spanclass="identifier">printf</span></code>, so you will have to use <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="keyword">int</span><spanclass="special">>(</span><spanclass="identifier">printf</span><spanclass="special">,</span><spanclass="special">...)</span></code>. Note
that an alternative <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">type</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(),</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
syntax is supported for portability reasons.
</p>
<p>
Another important factor to consider is that compilers without partial template
specialization or function template partial ordering support cannot handle
the first form when <codeclass="computeroutput"><spanclass="identifier">f</span></code> is
a function object, and in most cases will not handle the second form when
<codeclass="computeroutput"><spanclass="identifier">f</span></code> is a function (pointer)
or a member function pointer.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.faq.does_bind_work_with_windows_api_"></a><aclass="link"href="bind.html#bind.faq.does_bind_work_with_windows_api_"title="Does bind work with Windows API functions?">Does bind
work with Windows API functions?</a>
</h3></div></div></div>
<p>
Yes, if you <aclass="link"href="bind.html#bind.implementation.stdcall"title="__stdcall, __cdecl, __fastcall, and pascal Support"><codeclass="computeroutput"><spanclass="preprocessor">#define</span>
An alternative is to treat the function as a <aclass="link"href="bind.html#bind.purpose.with_function_objects"title="Using bind with function objects">generic
function object</a> and use the <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
syntax.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.faq.does_bind_work_with_com_methods"></a><aclass="link"href="bind.html#bind.faq.does_bind_work_with_com_methods"title="Does bind work with COM methods?">Does bind work
with COM methods?</a>
</h3></div></div></div>
<p>
Yes, if you <aclass="link"href="bind.html#bind.implementation.stdcall"title="__stdcall, __cdecl, __fastcall, and pascal Support"><codeclass="computeroutput"><spanclass="preprocessor">#define</span>
<aname="bind.faq.does_bind_work_with_mac_toolbox_"></a><aclass="link"href="bind.html#bind.faq.does_bind_work_with_mac_toolbox_"title="Does bind work with Mac toolbox functions?">Does bind
work with Mac toolbox functions?</a>
</h3></div></div></div>
<p>
Yes, if you <aclass="link"href="bind.html#bind.implementation.stdcall"title="__stdcall, __cdecl, __fastcall, and pascal Support"><codeclass="computeroutput"><spanclass="preprocessor">#define</span>
An alternative is to treat the function as a <aclass="link"href="bind.html#bind.purpose.with_function_objects"title="Using bind with function objects">generic
function object</a> and use the <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
syntax.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.faq.does_bind_work_with_extern_c_fun"></a><aclass="link"href="bind.html#bind.faq.does_bind_work_with_extern_c_fun"title='Does bind work with extern "C" functions?'>Does bind
work with extern "C" functions?</a>
</h3></div></div></div>
<p>
Sometimes. On some platforms, pointers to extern "C" functions
are equivalent to "ordinary" function pointers, so they work fine.
Other platforms treat them as different types. A platform-specific implementation
of <codeclass="computeroutput"><spanclass="identifier">bind</span></code> is expected to handle
the problem transparently; this implementation does not. As usual, the workaround
is to treat the function as a <aclass="link"href="bind.html#bind.purpose.with_function_objects"title="Using bind with function objects">generic
function object</a> and use the <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
Non-portable extensions, in general, should default to off to prevent vendor
lock-in. Had the <aclass="link"href="bind.html#bind.implementation.stdcall"title="__stdcall, __cdecl, __fastcall, and pascal Support">appropriate
macros</a> been defined automatically, you could have accidentally taken
advantage of them without realizing that your code is, perhaps, no longer
portable. In addition, some compilers have the option to make <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code> (<codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code>)
their default calling convention, in which case no separate support would
<aname="bind.troubleshooting.incorrect_number_of_arguments"></a><aclass="link"href="bind.html#bind.troubleshooting.incorrect_number_of_arguments"title="Incorrect number of arguments">Incorrect
number of arguments</a>
</h3></div></div></div>
<p>
In a <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">,</span>
<spanclass="special">...,</span><spanclass="identifier">aN</span><spanclass="special">)</span></code> expression, the function object <codeclass="computeroutput"><spanclass="identifier">f</span></code> must be able to take exactly N arguments.
This error is normally detected at "bind time"; in other words,
the compilation error is reported on the line where <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">()</span></code> is invoked:
<spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="number">1</span><spanclass="special">);</span><spanclass="comment">// error, f takes two arguments</span>
<aname="bind.troubleshooting.the_function_object_cannot_be_ca"></a><aclass="link"href="bind.html#bind.troubleshooting.the_function_object_cannot_be_ca"title="The function object cannot be called with the specified arguments">The
function object cannot be called with the specified arguments</a>
</h3></div></div></div>
<p>
As in normal function calls, the function object that is bound must be compatible
with the argument list. The incompatibility will usually be detected by the
compiler at "call time" and the result is typically an error in
<codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code> on a line that looks like:
<spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="string">"incompatible"</span><spanclass="special">);</span><spanclass="comment">// OK so far, no call</span>
<spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="string">"incompatible"</span><spanclass="special">)();</span><spanclass="comment">// error, "incompatible" is not an int</span>
<spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">)(</span><spanclass="string">"incompatible"</span><spanclass="special">);</span><spanclass="comment">// error, "incompatible" is not an int</span>
<spanclass="special">}</span>
</pre>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.troubleshooting.accessing_an_argument_that_does_"></a><aclass="link"href="bind.html#bind.troubleshooting.accessing_an_argument_that_does_"title="Accessing an argument that does not exist">Accessing
an argument that does not exist</a>
</h3></div></div></div>
<p>
The placeholder <codeclass="computeroutput"><spanclass="identifier">_N</span></code> selects
the argument at position <codeclass="computeroutput"><spanclass="identifier">N</span></code>
from the argument list passed at "call time." Naturally, it is
an error to attempt to access beyond the end of this list:
<spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">_1</span><spanclass="special">)();</span><spanclass="comment">// error, there is no argument number 1</span>
<spanclass="special">}</span>
</pre>
<p>
The error is usually reported in <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code>, at
When emulating <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">bind1st</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">a</span><spanclass="special">)</span></code>, a common mistake of this category is to
type <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">a</span><spanclass="special">,</span><spanclass="identifier">_2</span><spanclass="special">)</span></code>
instead of the correct <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span>
<aname="bind.troubleshooting.inappropriate_use_of_bind_f"></a><aclass="link"href="bind.html#bind.troubleshooting.inappropriate_use_of_bind_f"title="Inappropriate use of bind(f, ...)">Inappropriate
use of <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code></a>
</h3></div></div></div>
<p>
The <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">,</span>
<spanclass="special">...,</span><spanclass="identifier">aN</span><spanclass="special">)</span></code><aclass="link"href="bind.html#bind.faq.Q_forms"title="What is the difference between bind(f, ...) and bind<R>(f, ...)?">form</a>
causes automatic recognition of the type of <codeclass="computeroutput"><spanclass="identifier">f</span></code>.
It will not work with arbitrary function objects; <codeclass="computeroutput"><spanclass="identifier">f</span></code>
must be a function or a member function pointer.
</p>
<p>
It is possible to use this form with function objects that define <codeclass="computeroutput"><spanclass="identifier">result_type</span></code>, but only on compilers that
support partial specialization and partial ordering. In particular, MSVC
up to version 7.0 does not support this syntax for function objects.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.troubleshooting.inappropriate_use_of_bind_r_f"></a><aclass="link"href="bind.html#bind.troubleshooting.inappropriate_use_of_bind_r_f"title="Inappropriate use of bind<R>(f, ...)">Inappropriate
use of <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code></a>
</h3></div></div></div>
<p>
The <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">,</span>
<spanclass="special">...,</span><spanclass="identifier">aN</span><spanclass="special">)</span></code><aclass="link"href="bind.html#bind.faq.Q_forms"title="What is the difference between bind(f, ...) and bind<R>(f, ...)?">form</a>
supports arbitrary function objects.
</p>
<p>
It is possible (but not recommended) to use this form with functions or member
function pointers, but only on compilers that support partial ordering. In
particular, MSVC up to version 7.0 does not fully support this syntax for
functions and member function pointers.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.troubleshooting.binding_a_nonstandard_function"></a><aclass="link"href="bind.html#bind.troubleshooting.binding_a_nonstandard_function"title="Binding a nonstandard function">Binding
a nonstandard function</a>
</h3></div></div></div>
<p>
By default, the <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">,</span>
<spanclass="special">...,</span><spanclass="identifier">aN</span><spanclass="special">)</span></code><aclass="link"href="bind.html#bind.faq.Q_forms"title="What is the difference between bind(f, ...) and bind<R>(f, ...)?">form</a>
recognizes "ordinary" C++ functions and function pointers. <aclass="link"href="bind.html#bind.implementation.stdcall"title="__stdcall, __cdecl, __fastcall, and pascal Support">Functions that use a different calling
convention</a>, or variable-argument functions such as <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">printf</span></code>,
do not work. The general <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">,</span>
<spanclass="special">...,</span><spanclass="identifier">aN</span><spanclass="special">)</span></code><aclass="link"href="bind.html#bind.faq.Q_forms"title="What is the difference between bind(f, ...) and bind<R>(f, ...)?">form</a>
works with nonstandard functions.
</p>
<p>
On some platforms, extern "C" functions, like <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">strcmp</span></code>,
are not recognized by the short form of <codeclass="computeroutput"><spanclass="identifier">bind</span></code>.
</p>
<p>
See also <aclass="link"href="bind.html#bind.implementation.stdcall"title="__stdcall, __cdecl, __fastcall, and pascal Support"><codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code>
and <codeclass="computeroutput"><spanclass="identifier">pascal</span></code> Support</a>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.troubleshooting.binding_an_overloaded_function"></a><aclass="link"href="bind.html#bind.troubleshooting.binding_an_overloaded_function"title="Binding an overloaded function">Binding
an overloaded function</a>
</h3></div></div></div>
<p>
An attempt to bind an overloaded function usually results in an error, as
there is no way to tell which overload was meant to be bound. This is a common
problem with member functions with two overloads, const and non-const, as
<aname="bind.troubleshooting.modeling_stl_function_object_con"></a><aclass="link"href="bind.html#bind.troubleshooting.modeling_stl_function_object_con"title="Modeling STL function object concepts">Modeling
STL function object concepts</a>
</h3></div></div></div>
<p>
The function objects that are produced by <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
Function</em></span></a> concepts, even when the function objects are
unary or binary operations, because the function object types are missing
public typedefs <codeclass="computeroutput"><spanclass="identifier">result_type</span></code>
and <codeclass="computeroutput"><spanclass="identifier">argument_type</span></code> or <codeclass="computeroutput"><spanclass="identifier">first_argument_type</span></code> and <codeclass="computeroutput"><spanclass="identifier">second_argument_type</span></code>.
In cases where these typedefs are desirable, however, the utility function
<codeclass="computeroutput"><spanclass="identifier">make_adaptable</span></code> can be used
to adapt unary and binary function objects to these concepts. This allows
unary and binary function objects resulting from <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
to be combined with STL templates such as <ahref="http://en.cppreference.com/w/cpp/utility/functional/unary_negate"target="_top"><codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">unary_negate</span></code></a>
and <ahref="http://en.cppreference.com/w/cpp/utility/functional/binary_negate"target="_top"><codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">binary_negate</span></code></a>.
</p>
<p>
The <codeclass="computeroutput"><spanclass="identifier">make_adaptable</span></code> function
is defined in <ahref="../../../../boost/bind/make_adaptable.hpp"target="_top"><codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">make_adaptable</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code></a>,
which must be included explicitly in addition to <ahref="../../../../boost/bind/bind.hpp"target="_top"><codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code></a>:
In this example, <codeclass="computeroutput"><spanclass="identifier">bind</span></code> creates
the "is a space" (unary) predicate. It is then passed to <codeclass="computeroutput"><spanclass="identifier">make_adaptable</span></code> so that a function object
modeling the <spanclass="emphasis"><em>Unary Function</em></span> concept can be created,
serving as the argument to <ahref="http://en.cppreference.com/w/cpp/utility/functional/not1"target="_top"><codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">not1</span></code></a>.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.troubleshooting.const_in_signatures"></a><aclass="link"href="bind.html#bind.troubleshooting.const_in_signatures"title="const in signatures"><codeclass="computeroutput"><spanclass="keyword">const</span></code> in signatures</a>
</h3></div></div></div>
<p>
Some compilers, including MSVC 6.0 and Borland C++ 5.5.1, have problems with
the top-level <codeclass="computeroutput"><spanclass="keyword">const</span></code> in function
Workaround: remove the <codeclass="computeroutput"><spanclass="keyword">const</span></code>
qualifier from the argument.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.troubleshooting.msvc_specific_using_boost_bind"></a><aclass="link"href="bind.html#bind.troubleshooting.msvc_specific_using_boost_bind"title="MSVC specific: using boost::bind;">MSVC
On MSVC (up to version 7.0), when <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span></code>
the syntax <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
does not work. Workaround: either use the qualified name, <codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span></code>,
<aname="bind.troubleshooting.msvc_specific_class_templates_sh"></a><aclass="link"href="bind.html#bind.troubleshooting.msvc_specific_class_templates_sh"title="MSVC specific: class templates shadow function templates">MSVC
specific: class templates shadow function templates</a>
</h3></div></div></div>
<p>
On MSVC (up to version 7.0), a nested class template named <codeclass="computeroutput"><spanclass="identifier">bind</span></code> will shadow the function template
<codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">bind</span></code>, breaking the <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>syntax.
Unfortunately, some libraries contain nested class templates named <codeclass="computeroutput"><spanclass="identifier">bind</span></code> (ironically, such code is often an
MSVC specific workaround.)
</p>
<p>
The workaround is to use the alternative <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">type</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(),</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
syntax.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.troubleshooting.msvc_specific_in_signatures_trea"></a><aclass="link"href="bind.html#bind.troubleshooting.msvc_specific_in_signatures_trea"title="MSVC specific: ... in signatures treated as type">MSVC
specific: <codeclass="computeroutput"><spanclass="special">...</span></code> in signatures treated
as type</a>
</h3></div></div></div>
<p>
MSVC (up to version 7.0) treats the ellipsis in a variable argument function
(such as <codeclass="computeroutput"><spanclass="identifier">std</span><spanclass="special">::</span><spanclass="identifier">printf</span></code>) as a type. Therefore, it will accept
the (incorrect in the current implementation) form:
All <spanclass="emphasis"><em>unspecified-N</em></span> types returned by <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
are <spanclass="emphasis"><em>CopyConstructible</em></span>. <spanclass="emphasis"><em>unspecified-N</em></span><codeclass="computeroutput"><spanclass="special">::</span><spanclass="identifier">result_type</span></code>
is defined as the return type of <spanclass="emphasis"><em>unspecified-N</em></span><codeclass="computeroutput"><spanclass="special">::</span><spanclass="keyword">operator</span><spanclass="special">()</span></code>.
</p>
<p>
All <spanclass="emphasis"><em>unspecified-placeholder-N</em></span> types are <spanclass="emphasis"><em>CopyConstructible</em></span>.
The function μ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">x</span><spanclass="special">,</span><spanclass="identifier">v1</span><spanclass="special">,</span>
<spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">)</span></code>, where <codeclass="computeroutput"><spanclass="identifier">m</span></code>
when <codeclass="computeroutput"><spanclass="identifier">x</span></code> is of type <ahref="../../../../libs/core/doc/html/core/ref.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">reference_wrapper</span></code></a><codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">T</span><spanclass="special">></span></code> for some type <codeclass="computeroutput"><spanclass="identifier">T</span></code>;
</li>
<liclass="listitem">
<codeclass="computeroutput"><spanclass="identifier">vk</span></code>, when <codeclass="computeroutput"><spanclass="identifier">x</span></code> is (a copy of) the placeholder <spanclass="emphasis"><em>_k</em></span>
for some positive integer <spanclass="emphasis"><em>k</em></span>;
</li>
<liclass="listitem">
<codeclass="computeroutput"><spanclass="identifier">x</span><spanclass="special">(</span><spanclass="identifier">v1</span><spanclass="special">,</span><spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">)</span></code> when <codeclass="computeroutput"><spanclass="identifier">x</span></code>
is (a copy of) a function object returned by <codeclass="computeroutput"><spanclass="identifier">bind</span></code>;
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="keyword">typename</span>
is equivalent to <codeclass="computeroutput"><spanclass="identifier">f</span><spanclass="special">(</span></code>μ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">v1</span><spanclass="special">,</span><spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">))</span></code>,
implicitly converted to <codeclass="computeroutput"><spanclass="identifier">R</span></code>.
</li>
<liclass="listitem">
<spanclass="emphasis"><em>Throws:</em></span> Nothing unless the copy constructors of
<codeclass="computeroutput"><spanclass="identifier">F</span></code> or <codeclass="computeroutput"><spanclass="identifier">A1</span></code>
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="keyword">typename</span>
is equivalent to <codeclass="computeroutput"><spanclass="identifier">f</span><spanclass="special">(</span></code>μ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">v1</span><spanclass="special">,</span><spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">))</span></code>.
</li>
<liclass="listitem">
<spanclass="emphasis"><em>Throws:</em></span> Nothing unless the copy constructor of
<codeclass="computeroutput"><spanclass="identifier">A1</span></code> throws an exception.
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span></code><ahref="../../../../libs/bind/mem_fn.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span></code></a><codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">),</span><spanclass="identifier">a1</span><spanclass="special">)</span></code>.
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span></code><ahref="../../../../libs/bind/mem_fn.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span></code></a><codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">),</span><spanclass="identifier">a1</span><spanclass="special">)</span></code>.
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span></code><ahref="../../../../libs/bind/mem_fn.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span></code></a><codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">),</span><spanclass="identifier">a1</span><spanclass="special">)</span></code>.
is equivalent to <codeclass="computeroutput"><spanclass="identifier">f</span><spanclass="special">(</span></code>μ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">v1</span><spanclass="special">,</span><spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">),</span></code>μ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">a2</span><spanclass="special">,</span><spanclass="identifier">v1</span><spanclass="special">,</span><spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">))</span></code>,
implicitly converted to <codeclass="computeroutput"><spanclass="identifier">R</span></code>.
</li>
<liclass="listitem">
<spanclass="emphasis"><em>Throws:</em></span> Nothing unless the copy constructors of
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="keyword">typename</span>
is equivalent to <codeclass="computeroutput"><spanclass="identifier">f</span><spanclass="special">(</span></code>μ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">v1</span><spanclass="special">,</span><spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">),</span></code>μ<codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">a2</span><spanclass="special">,</span><spanclass="identifier">v1</span><spanclass="special">,</span><spanclass="identifier">v2</span><spanclass="special">,</span><spanclass="special">...,</span><spanclass="identifier">vm</span><spanclass="special">))</span></code>.
</li>
<liclass="listitem">
<spanclass="emphasis"><em>Throws:</em></span> Nothing unless the copy constructors of
<codeclass="computeroutput"><spanclass="identifier">A1</span></code> or <codeclass="computeroutput"><spanclass="identifier">A2</span></code>
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span></code><ahref="../../../../libs/bind/mem_fn.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span></code></a><codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">),</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">)</span></code>.
<spanclass="emphasis"><em>Effects:</em></span> Equivalent to <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(</span></code><ahref="../../../../libs/bind/mem_fn.html"target="_top"><codeclass="computeroutput"><spanclass="identifier">boost</span><spanclass="special">::</span><spanclass="identifier">mem_fn</span></code></a><codeclass="computeroutput"><spanclass="special">(</span><spanclass="identifier">f</span><spanclass="special">),</span><spanclass="identifier">a1</span><spanclass="special">,</span><spanclass="identifier">a2</span><spanclass="special">)</span></code>.
(used by <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code>, do not include directly)
(used by <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code>, do not include directly)
(used by <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code>, do not include directly)
<aname="bind.implementation.number_of_arguments"></a><aclass="link"href="bind.html#bind.implementation.number_of_arguments"title="Number of Arguments">Number of Arguments</a>
</h3></div></div></div>
<p>
This implementation supports function objects with up to nine arguments.
This is an implementation detail, not an inherent limitation of the design.
</p>
</div>
<divclass="section">
<divclass="titlepage"><div><div><h3class="title">
<aname="bind.implementation.stdcall"></a><aclass="link"href="bind.html#bind.implementation.stdcall"title="__stdcall, __cdecl, __fastcall, and pascal Support"><codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code>,
and <codeclass="computeroutput"><spanclass="identifier">pascal</span></code> Support</a>
</h3></div></div></div>
<p>
Some platforms allow several types of (member) functions that differ by their
calling convention (the rules by which the function is invoked: how are arguments
passed, how is the return value handled, and who cleans up the stack - if
any.)
</p>
<p>
For example, Windows API functions and COM interface member functions use
a calling convention known as <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code>.
Borland VCL components use <codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code>.
Mac toolbox functions use a <codeclass="computeroutput"><spanclass="identifier">pascal</span></code>
calling convention.
</p>
<p>
To use <codeclass="computeroutput"><spanclass="identifier">bind</span></code> with <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code> functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code>
the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_BIND_ENABLE_STDCALL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
To use <codeclass="computeroutput"><spanclass="identifier">bind</span></code> with <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code> member functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code> the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_MEM_FN_ENABLE_STDCALL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
To use <codeclass="computeroutput"><spanclass="identifier">bind</span></code> with <codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code> functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code>
the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_BIND_ENABLE_FASTCALL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
To use <codeclass="computeroutput"><spanclass="identifier">bind</span></code> with <codeclass="computeroutput"><spanclass="identifier">__fastcall</span></code> member functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code> the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_MEM_FN_ENABLE_FASTCALL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
To use <codeclass="computeroutput"><spanclass="identifier">bind</span></code> with <codeclass="computeroutput"><spanclass="identifier">pascal</span></code> functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code>
the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_BIND_ENABLE_PASCAL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
To use <codeclass="computeroutput"><spanclass="identifier">bind</span></code> with <codeclass="computeroutput"><spanclass="identifier">__cdecl</span></code> member functions, <codeclass="computeroutput"><spanclass="preprocessor">#define</span></code> the macro <codeclass="computeroutput"><spanclass="identifier">BOOST_MEM_FN_ENABLE_CDECL</span></code>
before including <codeclass="computeroutput"><spanclass="special"><</span><spanclass="identifier">boost</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">/</span><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span><spanclass="special">></span></code>.
<spanclass="bold"><strong>It is best to define these macros in the project options,
via <codeclass="computeroutput"><spanclass="special">-</span><spanclass="identifier">D</span></code>
on the command line, or as the first line in the translation unit (.cpp file)
where <codeclass="computeroutput"><spanclass="identifier">bind</span></code> is used.</strong></span>
Not following this rule can lead to obscure errors when a header includes
<codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">.</span><spanclass="identifier">hpp</span></code> before the macro has been defined.
</p>
<p>
<spanclass="emphasis"><em>[Note:</em></span> this is a non-portable extension. It is not part
of the interface.<spanclass="emphasis"><em>]</em></span>
</p>
<p>
<spanclass="emphasis"><em>[Note:</em></span> Some compilers provide only minimal support for
the <codeclass="computeroutput"><spanclass="identifier">__stdcall</span></code> keyword.<spanclass="emphasis"><em>]</em></span>
The <ahref="http://staff.cs.utu.fi/BL/"target="_top">Binder Library</a> by Jaakko
Järvi;
</li>
<liclass="listitem">
The <ahref="../../../../libs/lambda/index.html"target="_top">Lambda Library</a> (now
part of Boost) by Jaakko Järvi and Gary Powell (the successor to the
Binder Library);
</li>
<liclass="listitem">
<ahref="http://more.sourceforge.net/"target="_top">Extensions to the STL</a>
by Petter Urkedal.
</li>
</ul></div>
<p>
Doug Gregor suggested that a visitor mechanism would allow <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
to interoperate with a signal/slot library.
</p>
<p>
John Maddock fixed a MSVC-specific conflict between <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
and the <ahref="../../../../libs/type_traits/index.html"target="_top">type traits library</a>.
</p>
<p>
Numerous improvements were suggested during the formal review period by Ross
Smith, Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was
Darin Adler.
</p>
<p>
The precise semantics of <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
were refined in discussions with Jaakko Järvi.
</p>
<p>
Dave Abrahams fixed a MSVC-specific conflict between <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
and the <ahref="../../../../libs/utility/iterator_adaptors.htm"target="_top">iterator adaptors
library</a>.
</p>
<p>
Dave Abrahams modified <codeclass="computeroutput"><spanclass="identifier">bind</span></code>
and <codeclass="computeroutput"><spanclass="identifier">mem_fn</span></code> to support <codeclass="computeroutput"><spanclass="keyword">void</span></code> returns on deficient compilers.
</p>
<p>
Mac Murrett contributed the "pascal" support enabled by <codeclass="computeroutput"><spanclass="identifier">BOOST_BIND_ENABLE_PASCAL</span></code>.
</p>
<p>
The alternative <codeclass="computeroutput"><spanclass="identifier">bind</span><spanclass="special">(</span><spanclass="identifier">type</span><spanclass="special"><</span><spanclass="identifier">R</span><spanclass="special">>(),</span><spanclass="identifier">f</span><spanclass="special">,</span><spanclass="special">...)</span></code>
syntax was inspired by a discussion with Dave Abrahams and Joel de Guzman.
</p>
<p>
This documentation was ported to Quickbook by Agustín Bergé.
