forked from boostorg/bind
Merge branch 'develop'
This commit is contained in:
Peter Dimov
50
doc/Jamfile.v2
Normal file
50
doc/Jamfile.v2
Normal file
@@ -0,0 +1,50 @@
|
||||
# Copyright (c) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
|
||||
|
||||
# Distributed under the Boost Software License, Version 1.0.
|
||||
# (See accompanying file LICENSE_1_0.txt or copy at
|
||||
# http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
project doc/bind ;
|
||||
|
||||
import boostbook ;
|
||||
import quickbook ;
|
||||
|
||||
xml bind_ : bind.qbk ;
|
||||
boostbook standalone_bind
|
||||
:
|
||||
bind_
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
# File name of HTML output:
|
||||
<xsl:param>root.filename=bind
|
||||
# How far down we chunk nested sections, basically all of them:
|
||||
<xsl:param>chunk.section.depth=0
|
||||
# Don't put the first section on the same page as the TOC:
|
||||
<xsl:param>chunk.first.sections=0
|
||||
# How far down sections get TOC's
|
||||
<xsl:param>toc.section.depth=2
|
||||
# Max depth in each TOC:
|
||||
<xsl:param>toc.max.depth=2
|
||||
# How far down we go with TOC's
|
||||
<xsl:param>generate.section.toc.level=0
|
||||
;
|
||||
|
||||
xml mem_fn_ : mem_fn.qbk ;
|
||||
boostbook standalone_mem_fn
|
||||
:
|
||||
mem_fn_
|
||||
:
|
||||
<xsl:param>boost.root=../../../..
|
||||
# File name of HTML output:
|
||||
<xsl:param>root.filename=mem_fn
|
||||
# How far down we chunk nested sections, basically all of them:
|
||||
<xsl:param>chunk.section.depth=0
|
||||
# Don't put the first section on the same page as the TOC:
|
||||
<xsl:param>chunk.first.sections=0
|
||||
# How far down sections get TOC's
|
||||
<xsl:param>toc.section.depth=2
|
||||
# Max depth in each TOC:
|
||||
<xsl:param>toc.max.depth=2
|
||||
# How far down we go with TOC's
|
||||
<xsl:param>generate.section.toc.level=0
|
||||
;
|
||||
35
doc/bind.qbk
Normal file
35
doc/bind.qbk
Normal file
@@ -0,0 +1,35 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[library Boost.Bind
|
||||
[quickbook 1.6]
|
||||
[id bind]
|
||||
[copyright 2001, 2002 Peter Dimov and Multi Media Ltd.]
|
||||
[copyright 2003-2008 Peter Dimov]
|
||||
[dirname bind]
|
||||
[license Distributed under the
|
||||
[@http://boost.org/LICENSE_1_0.txt Boost Software License,
|
||||
Version 1.0].
|
||||
]
|
||||
]
|
||||
|
||||
[template simplesect[title]
|
||||
[block '''<simplesect><title>'''[title]'''</title>''']]
|
||||
|
||||
[template endsimplesect[]
|
||||
[block '''</simplesect>''']]
|
||||
|
||||
[include bind/purpose.qbk]
|
||||
[include bind/examples.qbk]
|
||||
[include bind/limitations.qbk]
|
||||
[include bind/faq.qbk]
|
||||
[include bind/troubleshooting.qbk]
|
||||
[include bind/interface.qbk]
|
||||
[include bind/implementation.qbk]
|
||||
[include bind/acknowledgements.qbk]
|
||||
48
doc/bind/acknowledgements.qbk
Normal file
48
doc/bind/acknowledgements.qbk
Normal file
@@ -0,0 +1,48 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:acknowledgements Acknowledgements]
|
||||
|
||||
Earlier efforts that have influenced the library design:
|
||||
|
||||
* The [@http://staff.cs.utu.fi/BL/ Binder Library] by Jaakko J\u00E4rvi;
|
||||
|
||||
* The [@boost:/libs/lambda/index.html Lambda Library] (now part of Boost) by
|
||||
Jaakko J\u00E4rvi and Gary Powell (the successor to the Binder Library);
|
||||
|
||||
* [@http://more.sourceforge.net/ Extensions to the STL] by Petter Urkedal.
|
||||
|
||||
Doug Gregor suggested that a visitor mechanism would allow `bind` to
|
||||
interoperate with a signal/slot library.
|
||||
|
||||
John Maddock fixed a MSVC-specific conflict between `bind` and the
|
||||
[@boost:/libs/type_traits/index.html type traits library].
|
||||
|
||||
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.
|
||||
|
||||
The precise semantics of `bind` were refined in discussions with Jaakko
|
||||
J\u00E4rvi.
|
||||
|
||||
Dave Abrahams fixed a MSVC-specific conflict between `bind` and the
|
||||
[@boost:/libs/utility/iterator_adaptors.htm iterator adaptors library].
|
||||
|
||||
Dave Abrahams modified `bind` and `mem_fn` to support `void` returns on
|
||||
deficient compilers.
|
||||
|
||||
Mac Murrett contributed the "pascal" support enabled by
|
||||
`BOOST_BIND_ENABLE_PASCAL`.
|
||||
|
||||
The alternative `bind(type<R>(), f, ...)` syntax was inspired by a discussion
|
||||
with Dave Abrahams and Joel de Guzman.
|
||||
|
||||
This documentation was ported to Quickbook by Agustín Bergé.
|
||||
|
||||
[endsect]
|
||||
70
doc/bind/examples.qbk
Normal file
70
doc/bind/examples.qbk
Normal file
@@ -0,0 +1,70 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:examples Examples]
|
||||
|
||||
[section Using bind with standard algorithms]
|
||||
|
||||
class image;
|
||||
|
||||
class animation
|
||||
{
|
||||
public:
|
||||
void advance(int ms);
|
||||
bool inactive() const;
|
||||
void render(image & target) const;
|
||||
};
|
||||
|
||||
std::vector<animation> anims;
|
||||
|
||||
template<class C, class P> void erase_if(C & c, P pred)
|
||||
{
|
||||
c.erase(std::remove_if(c.begin(), c.end(), pred), c.end());
|
||||
}
|
||||
|
||||
void update(int ms)
|
||||
{
|
||||
std::for_each(anims.begin(), anims.end(), boost::bind(&animation::advance, _1, ms));
|
||||
erase_if(anims, boost::mem_fn(&animation::inactive));
|
||||
}
|
||||
|
||||
void render(image & target)
|
||||
{
|
||||
std::for_each(anims.begin(), anims.end(), boost::bind(&animation::render, _1, boost::ref(target)));
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Using bind with Boost.Function]
|
||||
|
||||
class button
|
||||
{
|
||||
public:
|
||||
``[@boost:/libs/function/index.html `boost::function`]``<void()> onClick;
|
||||
};
|
||||
|
||||
class player
|
||||
{
|
||||
public:
|
||||
void play();
|
||||
void stop();
|
||||
};
|
||||
|
||||
button playButton, stopButton;
|
||||
player thePlayer;
|
||||
|
||||
void connect()
|
||||
{
|
||||
playButton.onClick = boost::bind(&player::play, &thePlayer);
|
||||
stopButton.onClick = boost::bind(&player::stop, &thePlayer);
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
99
doc/bind/faq.qbk
Normal file
99
doc/bind/faq.qbk
Normal file
@@ -0,0 +1,99 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:faq Frequently Asked Questions]
|
||||
|
||||
[section Why doesn't this compile?]
|
||||
|
||||
See the dedicated [link bind.troubleshooting Troubleshooting section].
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Why does this compile? It should not.]
|
||||
|
||||
Probably because you used the general `bind<R>(f, ...)` syntax, thereby
|
||||
instructing `bind` to not "inspect" f to detect arity and return type errors.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:Q_forms What is the difference between `bind(f, ...)` and `bind<R>(f, ...)`?]
|
||||
|
||||
The first form instructs `bind` to inspect the type of `f` 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 `f`. It must be a function, function pointer, member function pointer, or a
|
||||
function object that defines a nested type named `result_type`; in short, it
|
||||
must be something that `bind` can recognize.
|
||||
|
||||
The second form instructs `bind` to not attempt to recognize the type of `f`.
|
||||
It is generally used with function objects that do not, or cannot, expose
|
||||
`result_type`, but it can also be used with nonstandard functions. For example,
|
||||
the current implementation does not automatically recognize variable-argument
|
||||
functions like `printf`, so you will have to use `bind<int>(printf, ...)`.
|
||||
Note that an alternative `bind(type<R>(), f, ...)` syntax is supported for
|
||||
portability reasons.
|
||||
|
||||
Another important factor to consider is that compilers without partial
|
||||
template specialization or function template partial ordering support cannot
|
||||
handle the first form when `f` is a function object, and in most cases will
|
||||
not handle the second form when `f` is a function (pointer) or a member
|
||||
function pointer.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Does bind work with Windows API functions?]
|
||||
|
||||
Yes, if you [link bind.implementation.stdcall `#define
|
||||
BOOST_BIND_ENABLE_STDCALL`]. An alternative is to treat the function as a
|
||||
[link bind.purpose.with_function_objects generic function object] and use the
|
||||
`bind<R>(f, ...)` syntax.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Does bind work with COM methods?]
|
||||
|
||||
Yes, if you [link bind.implementation.stdcall `#define
|
||||
BOOST_MEM_FN_ENABLE_STDCALL`].
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Does bind work with Mac toolbox functions?]
|
||||
|
||||
Yes, if you [link bind.implementation.stdcall `#define
|
||||
BOOST_BIND_ENABLE_PASCAL`]. An alternative is to treat the function as a [link
|
||||
bind.purpose.with_function_objects generic function object] and use the
|
||||
`bind<R>(f, ...)` syntax.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Does bind work with extern "C" functions?]
|
||||
|
||||
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 `bind` is expected
|
||||
to handle the problem transparently; this implementation does not. As usual,
|
||||
the workaround is to treat the function as a [link
|
||||
bind.purpose.with_function_objects generic function object] and use the
|
||||
`bind<R>(f, ...)` syntax.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Why doesn't bind automatically recognize nonstandard functions?]
|
||||
|
||||
Non-portable extensions, in general, should default to off to prevent vendor
|
||||
lock-in. Had the [link bind.implementation.stdcall appropriate macros] 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 `__stdcall` (`__fastcall`) their
|
||||
default calling convention, in which case no separate support would be
|
||||
necessary.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
98
doc/bind/implementation.qbk
Normal file
98
doc/bind/implementation.qbk
Normal file
@@ -0,0 +1,98 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:implementation Implementation]
|
||||
|
||||
[section Files]
|
||||
|
||||
* [@../../include/boost/bind.hpp boost/bind.hpp] (main header)
|
||||
* [@../../include/boost/bind/bind_cc.hpp boost/bind/bind_cc.hpp] (used by `bind.hpp`, do not include directly)
|
||||
* [@../../include/boost/bind/bind_mf_cc.hpp boost/bind/bind_mf_cc.hpp] (used by `bind.hpp`, do not include directly)
|
||||
* [@../../include/boost/bind/bind_template.hpp boost/bind/bind_template.hpp] (used by `bind.hpp`, do not include directly)
|
||||
* [@../../include/boost/bind/arg.hpp boost/bind/arg.hpp] (defines the type of the placeholder arguments)
|
||||
* [@../../include/boost/bind/placeholders.hpp boost/bind/placeholders.hpp] (defines the `_1`, `_2`, ... `_9` placeholders)
|
||||
* [@../../include/boost/bind/apply.hpp boost/bind/apply.hpp] (`apply` helper function object)
|
||||
* [@../../include/boost/bind/protect.hpp boost/bind/protect.hpp] (`protect` helper function)
|
||||
* [@../../include/boost/bind/make_adaptable.hpp boost/bind/make_adaptable.hpp] (`make_adaptable` helper function)
|
||||
* [@../../test/bind_test.cpp libs/bind/test/bind_test.cpp] (test)
|
||||
* [@../../bind_as_compose.cpp libs/bind/bind_as_compose.cpp] (function composition example)
|
||||
* [@../../bind_visitor.cpp libs/bind/bind_visitor.cpp] (visitor example)
|
||||
* [@../../test/bind_stdcall_test.cpp libs/bind/test/bind_stdcall_test.cpp] (test with `__stdcall` functions)
|
||||
* [@../../test/bind_stdcall_mf_test.cpp libs/bind/test/bind_stdcall_mf_test.cpp] (test with `__stdcall` member functions)
|
||||
* [@../../test/bind_fastcall_test.cpp libs/bind/test/bind_fastcall_test.] (test with `__fastcall` functions)
|
||||
* [@../../test/bind_fastcall_mf_test.cpp libs/bind/test/bind_fastcall_mf_test.cpp] (test with `__fastcall` member functions)
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Dependencies]
|
||||
|
||||
* [@boost:/libs/config/config.htm Boost.Config]
|
||||
* [@boost:/libs/core/doc/html/core/ref.html boost/ref.hpp]
|
||||
* [@boost:/libs/bind/mem_fn.html boost/mem_fn.hpp]
|
||||
* [@boost:/boost/type.hpp boost/type.hpp]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Number of Arguments]
|
||||
|
||||
This implementation supports function objects with up to nine arguments. This
|
||||
is an implementation detail, not an inherent limitation of the design.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:stdcall `__stdcall`, `__cdecl`, `__fastcall`, and `pascal` Support]
|
||||
|
||||
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.)
|
||||
|
||||
For example, Windows API functions and COM interface member functions use a
|
||||
calling convention known as `__stdcall`. Borland VCL components use
|
||||
`__fastcall`. Mac toolbox functions use a `pascal` calling convention.
|
||||
|
||||
To use `bind` with `__stdcall` functions, `#define` the macro
|
||||
`BOOST_BIND_ENABLE_STDCALL` before including `<boost/bind.hpp>`.
|
||||
|
||||
To use `bind` with `__stdcall` member functions, `#define` the macro
|
||||
`BOOST_MEM_FN_ENABLE_STDCALL` before including `<boost/bind.hpp>`.
|
||||
|
||||
To use `bind` with `__fastcall` functions, `#define` the macro
|
||||
`BOOST_BIND_ENABLE_FASTCALL` before including `<boost/bind.hpp>`.
|
||||
|
||||
To use `bind` with `__fastcall` member functions, `#define` the macro
|
||||
`BOOST_MEM_FN_ENABLE_FASTCALL` before including `<boost/bind.hpp>`.
|
||||
|
||||
To use `bind` with `pascal` functions, `#define` the macro
|
||||
`BOOST_BIND_ENABLE_PASCAL` before including `<boost/bind.hpp>`.
|
||||
|
||||
To use `bind` with `__cdecl` member functions, `#define` the macro
|
||||
`BOOST_MEM_FN_ENABLE_CDECL` before including `<boost/bind.hpp>`.
|
||||
|
||||
[*It is best to define these macros in the project options, via `-D` on the
|
||||
command line, or as the first line in the translation unit (.cpp file) where
|
||||
`bind` is used.] Not following this rule can lead to obscure errors when a
|
||||
header includes `bind.hpp` before the macro has been defined.
|
||||
|
||||
/[Note:/ this is a non-portable extension. It is not part of the interface./]/
|
||||
|
||||
/[Note:/ Some compilers provide only minimal support for the `__stdcall` keyword./]/
|
||||
|
||||
[endsect]
|
||||
|
||||
[section `visit_each` support]
|
||||
|
||||
Function objects returned by `bind` support the experimental and undocumented,
|
||||
as of yet, `visit_each` enumeration interface.
|
||||
|
||||
See [@../../bind_visitor.cpp bind_visitor.cpp] for an example.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
216
doc/bind/interface.qbk
Normal file
216
doc/bind/interface.qbk
Normal file
@@ -0,0 +1,216 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:interface Interface]
|
||||
|
||||
[section:synopsys Synopsis]
|
||||
|
||||
namespace boost
|
||||
{
|
||||
// no arguments
|
||||
|
||||
template<class R, class F> ``/unspecified-1/`` ``[link bind_1 `bind`]``(F f);
|
||||
|
||||
template<class F> ``/unspecified-1-1/`` ``[link bind_1_1 `bind`]``(F f);
|
||||
|
||||
template<class R> ``/unspecified-2/`` ``[link bind_2 `bind`]``(R (*f) ());
|
||||
|
||||
// one argument
|
||||
|
||||
template<class R, class F, class A1> ``/unspecified-3/`` ``[link bind_3 `bind`]``(F f, A1 a1);
|
||||
|
||||
template<class F, class A1> ``/unspecified-3-1/`` ``[link bind_3_1 `bind`]``(F f, A1 a1);
|
||||
|
||||
template<class R, class B1, class A1> ``/unspecified-4/`` ``[link bind_4 `bind`]``(R (*f) (B1), A1 a1);
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-5/`` ``[link bind_5 `bind`]``(R (T::*f) (), A1 a1);
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-6/`` ``[link bind_6 `bind`]``(R (T::*f) () const, A1 a1);
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-6-1/`` ``[link bind_6_1 `bind`]``(R T::*f, A1 a1);
|
||||
|
||||
// two arguments
|
||||
|
||||
template<class R, class F, class A1, class A2> ``/unspecified-7/`` ``[link bind_7 `bind`]``(F f, A1 a1, A2 a2);
|
||||
|
||||
template<class F, class A1, class A2> ``/unspecified-7-1/`` ``[link bind_7_1 `bind`]``(F f, A1 a1, A2 a2);
|
||||
|
||||
template<class R, class B1, class B2, class A1, class A2> ``/unspecified-8/`` ``[link bind_8 `bind`]``(R (*f) (B1, B2), A1 a1, A2 a2);
|
||||
|
||||
template<class R, class T, class B1, class A1, class A2> ``/unspecified-9/`` ``[link bind_9 `bind`]``(R (T::*f) (B1), A1 a1, A2 a2);
|
||||
|
||||
template<class R, class T, class B1, class A1, class A2> ``/unspecified-10/`` ``[link bind_10 `bind`]``(R (T::*f) (B1) const, A1 a1, A2 a2);
|
||||
|
||||
// implementation defined number of additional overloads for more arguments
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
``/unspecified-placeholder-type-1/`` _1;
|
||||
|
||||
``/unspecified-placeholder-type-2/`` _2;
|
||||
|
||||
``/unspecified-placeholder-type-3/`` _3;
|
||||
|
||||
// implementation defined number of additional placeholder definitions
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Common requirements]
|
||||
|
||||
All /unspecified-N/ types returned by `bind` are /CopyConstructible/. /unspecified-N/`::result_type` is defined as the return type of /unspecified-N/`::operator()`.
|
||||
|
||||
All /unspecified-placeholder-N/ types are /CopyConstructible/. Their copy constructors do not throw exceptions.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Common definitions]
|
||||
|
||||
The function \u03BC`(x, v1, v2, ..., vm)`, where `m` is a nonnegative integer, is
|
||||
defined as:
|
||||
|
||||
* `x.get()`, when `x` is of type [@boost:/libs/core/doc/html/core/ref.html `boost::reference_wrapper`]`<T>` for some type
|
||||
`T`;
|
||||
|
||||
* `vk`, when `x` is (a copy of) the placeholder /_k/ for some positive integer
|
||||
/k/;
|
||||
|
||||
* `x(v1, v2, ..., vm)` when `x` is (a copy of) a function object returned by
|
||||
`bind`;
|
||||
|
||||
* `x` otherwise.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section `bind`]
|
||||
|
||||
[#bind_1]
|
||||
|
||||
template<class R, class F> ``/unspecified-1/`` bind(F f)
|
||||
|
||||
* /Returns:/ A function object \u03BB such that the expression \u03BB`(v1, v2, ..., vm)`
|
||||
is equivalent to `f()`, implicitly converted to `R`.
|
||||
|
||||
* /Throws:/ Nothing unless the copy constructor of `F` throws an exception.
|
||||
|
||||
[#bind_1_1]
|
||||
|
||||
template<class F> ``/unspecified-1-1/`` bind(F f)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<typename F::result_type, F>(f)`.
|
||||
|
||||
* /Notes:/ Implementations are allowed to infer the return type of `f` via other
|
||||
means as an extension, without relying on the `result_type` member.
|
||||
|
||||
[#bind_2]
|
||||
|
||||
template<class R> ``/unspecified-2/`` bind(R (*f) ())
|
||||
|
||||
* /Returns:/ A function object \u03BB such that the expression \u03BB`(v1, v2, ..., vm)`
|
||||
is equivalent to `f()`.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[#bind_3]
|
||||
|
||||
template<class R, class F, class A1> ``/unspecified-3/`` bind(F f, A1 a1)
|
||||
|
||||
* /Returns:/ A function object \u03BB such that the expression \u03BB`(v1, v2, ..., vm)`
|
||||
is equivalent to `f(`\u03BC`(a1, v1, v2, ..., vm))`, implicitly converted to `R`.
|
||||
|
||||
* /Throws:/ Nothing unless the copy constructors of `F` or `A1` throw an exception.
|
||||
|
||||
[#bind_3_1]
|
||||
|
||||
template<class F, class A1> ``/unspecified-3-1/`` bind(F f, A1 a1)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<typename F::result_type, F, A1>(f, a1)`.
|
||||
|
||||
* /Notes:/ Implementations are allowed to infer the return type of `f` via other
|
||||
means as an extension, without relying on the `result_type` member.
|
||||
|
||||
[#bind_4]
|
||||
|
||||
template<class R, class B1, class A1> ``/unspecified-4/`` bind(R (*f) (B1), A1 a1)
|
||||
|
||||
* /Returns:/ A function object \u03BB such that the expression \u03BB`(v1, v2, ..., vm)`
|
||||
is equivalent to `f(`\u03BC`(a1, v1, v2, ..., vm))`.
|
||||
|
||||
* /Throws:/ Nothing unless the copy constructor of `A1` throws an exception.
|
||||
|
||||
[#bind_5]
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-5/`` bind(R (T::*f) (), A1 a1)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<R>(`[@boost:/libs/bind/mem_fn.html `boost::mem_fn`]`(f), a1)`.
|
||||
|
||||
[#bind_6]
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-6/`` bind(R (T::*f) () const, A1 a1)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<R>(`[@boost:/libs/bind/mem_fn.html `boost::mem_fn`]`(f), a1)`.
|
||||
|
||||
[#bind_6_1]
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-6-1/`` bind(R T::*f, A1 a1)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<R>(`[@boost:/libs/bind/mem_fn.html `boost::mem_fn`]`(f), a1)`.
|
||||
|
||||
[#bind_7]
|
||||
|
||||
template<class R, class F, class A1, class A2> ``/unspecified-7/`` bind(F f, A1 a1, A2 a2)
|
||||
|
||||
* /Returns:/ A function object \u03BB such that the expression \u03BB`(v1, v2, ..., vm)`
|
||||
is equivalent to `f(`\u03BC`(a1, v1, v2, ..., vm), `\u03BC`(a2, v1, v2, ..., vm))`,
|
||||
implicitly converted to `R`.
|
||||
|
||||
* /Throws:/ Nothing unless the copy constructors of `F`, `A1` or `A2` throw an
|
||||
exception.
|
||||
|
||||
[#bind_7_1]
|
||||
|
||||
template<class F, class A1, class A2> ``/unspecified-7-1/`` bind(F f, A1 a1, A2 a2)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<typename F::result_type, F, A1, A2>(f, a1, a2)`.
|
||||
|
||||
* /Notes:/ Implementations are allowed to infer the return type of `f` via other
|
||||
means as an extension, without relying on the `result_type` member.
|
||||
|
||||
[#bind_8]
|
||||
|
||||
template<class R, class B1, class B2, class A1, class A2> ``/unspecified-8/`` bind(R (*f) (B1, B2), A1 a1, A2 a2)
|
||||
|
||||
* /Returns:/ A function object \u03BB such that the expression \u03BB`(v1, v2, ..., vm)`
|
||||
is equivalent to `f(`\u03BC`(a1, v1, v2, ..., vm), `\u03BC`(a2, v1, v2, ..., vm))`.
|
||||
|
||||
* /Throws:/ Nothing unless the copy constructors of `A1` or `A2` throw an exception.
|
||||
|
||||
[#bind_9]
|
||||
|
||||
template<class R, class T, class B1, class A1, class A2> ``/unspecified-9/`` bind(R (T::*f) (B1), A1 a1, A2 a2)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<R>(`[@boost:/libs/bind/mem_fn.html `boost::mem_fn`]`(f), a1, a2)`.
|
||||
|
||||
[#bind_10]
|
||||
|
||||
template<class R, class T, class B1, class A1, class A2> ``/unspecified-10/`` bind(R (T::*f) (B1) const, A1 a1, A2 a2)
|
||||
|
||||
* /Effects:/ Equivalent to `bind<R>(`[@boost:/libs/bind/mem_fn.html `boost::mem_fn`]`(f), a1, a2)`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Additional overloads]
|
||||
|
||||
Implementations are allowed to provide additional `bind` overloads in order to
|
||||
support more arguments or different function pointer variations.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
37
doc/bind/limitations.qbk
Normal file
37
doc/bind/limitations.qbk
Normal file
@@ -0,0 +1,37 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:limitations Limitations]
|
||||
|
||||
As a general rule, the function objects generated by `bind` take their
|
||||
arguments by reference and cannot, therefore, accept non-const temporaries or
|
||||
literal constants. This is an inherent limitation of the C++ language in its
|
||||
current (2003) incarnation, known as the [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm forwarding problem].
|
||||
(It will be fixed in the next standard, usually called C++0x.)
|
||||
|
||||
The library uses signatures of the form
|
||||
|
||||
template<class T> void f(T & t);
|
||||
|
||||
to accept arguments of arbitrary types and pass them on unmodified. As noted,
|
||||
this does not work with non-const r-values.
|
||||
|
||||
On compilers that support partial ordering of function templates, a possible
|
||||
solution is to add an overload:
|
||||
|
||||
template<class T> void f(T & t);
|
||||
template<class T> void f(T const & t);
|
||||
|
||||
Unfortunately, this requires providing 512 overloads for nine arguments, which
|
||||
is impractical. The library chooses a small subset: for up to two arguments,
|
||||
it provides the const overloads in full, for arities of three and more it
|
||||
provides a single additional overload with all of the arguments taken by const
|
||||
reference. This covers a reasonable portion of the use cases.
|
||||
|
||||
[endsect]
|
||||
273
doc/bind/purpose.qbk
Normal file
273
doc/bind/purpose.qbk
Normal file
@@ -0,0 +1,273 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:purpose Purpose]
|
||||
|
||||
`boost::bind` is a generalization of the standard functions `std::bind1st` and
|
||||
`std::bind2nd`. 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. `bind` does
|
||||
not place any requirements on the function object; in particular, it does not
|
||||
need the `result_type`, `first_argument_type` and `second_argument_type`
|
||||
standard typedefs.
|
||||
|
||||
[section Using bind with functions and function pointers]
|
||||
|
||||
Given these definitions:
|
||||
|
||||
int f(int a, int b)
|
||||
{
|
||||
return a + b;
|
||||
}
|
||||
|
||||
int g(int a, int b, int c)
|
||||
{
|
||||
return a + b + c;
|
||||
}
|
||||
|
||||
`bind(f, 1, 2)` will produce a "nullary" function object that takes no
|
||||
arguments and returns `f(1, 2)`. Similarly, `bind(g, 1, 2, 3)()` is equivalent
|
||||
`to g(1, 2, 3)`.
|
||||
|
||||
It is possible to selectively bind only some of the arguments.
|
||||
`bind(f, _1, 5)(x)` is equivalent to `f(x, 5)`; here `_1` is a /placeholder/
|
||||
argument that means "substitute with the first input argument."
|
||||
|
||||
For comparison, here is the same operation expressed with the standard library
|
||||
primitives:
|
||||
|
||||
std::bind2nd(std::ptr_fun(f), 5)(x);
|
||||
|
||||
`bind` covers the functionality of `std::bind1st` as well:
|
||||
|
||||
std::bind1st(std::ptr_fun(f), 5)(x); // f(5, x)
|
||||
bind(f, 5, _1)(x); // f(5, x)
|
||||
|
||||
`bind` can handle functions with more than two arguments, and its argument
|
||||
substitution mechanism is more general:
|
||||
|
||||
bind(f, _2, _1)(x, y); // f(y, x)
|
||||
bind(g, _1, 9, _1)(x); // g(x, 9, x)
|
||||
bind(g, _3, _3, _3)(x, y, z); // g(z, z, z)
|
||||
bind(g, _1, _1, _1)(x, y, z); // g(x, x, x)
|
||||
|
||||
Note that, in the last example, the function object produced by
|
||||
`bind(g, _1, _1, _1)` 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.
|
||||
|
||||
The arguments that `bind` takes are copied and held internally by the returned
|
||||
function object. For example, in the following code:
|
||||
|
||||
int i = 5;
|
||||
bind(f, i, _1);
|
||||
|
||||
a copy of the value of `i` is stored into the function object.
|
||||
[@boost:/libs/core/doc/html/core/ref.html `boost::ref`] and
|
||||
[@boost:/libs/core/doc/html/core/ref.html `boost::cref`] can be used to make the function
|
||||
object store a reference to an object, rather than a copy:
|
||||
|
||||
int i = 5;
|
||||
bind(f, ref(i), _1);
|
||||
bind(f, cref(i), _1);
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:with_function_objects Using bind with function objects]
|
||||
|
||||
`bind` is not limited to functions; it accepts arbitrary function objects. In
|
||||
the general case, the return type of the generated function object's
|
||||
`operator()` has to be specified explicitly (without a `typeof` operator the
|
||||
return type cannot be inferred):
|
||||
|
||||
struct F
|
||||
{
|
||||
int operator()(int a, int b) { return a - b; }
|
||||
bool operator()(long a, long b) { return a == b; }
|
||||
};
|
||||
|
||||
F f;
|
||||
int x = 104;
|
||||
bind<int>(f, _1, _1)(x); // f(x, x), i.e. zero
|
||||
|
||||
Some compilers have trouble with the `bind<R>(f, ...)` syntax. For portability
|
||||
reasons, an alternative way to express the above is supported:
|
||||
|
||||
boost::bind(boost::type<int>(), f, _1, _1)(x);
|
||||
|
||||
Note, however, that the alternative syntax is provided only as a workaround.
|
||||
It is not part of the interface.
|
||||
|
||||
When the function object exposes a nested type named `result_type`, the explicit
|
||||
return type can be omitted:
|
||||
|
||||
int x = 8;
|
||||
bind(std::less<int>(), _1, 9)(x); // x < 9
|
||||
|
||||
/[Note:/ the ability to omit the return type is not available on all compilers./]/
|
||||
|
||||
By default, `bind` makes a copy of the provided function object. `boost::ref`
|
||||
and `boost::cref` 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 is not destroyed
|
||||
while it's still being used.
|
||||
|
||||
struct F2
|
||||
{
|
||||
int s;
|
||||
|
||||
typedef void result_type;
|
||||
void operator()(int x) { s += x; }
|
||||
};
|
||||
|
||||
F2 f2 = { 0 };
|
||||
int a[] = { 1, 2, 3 };
|
||||
|
||||
std::for_each(a, a+3, bind(ref(f2), _1));
|
||||
|
||||
assert(f2.s == 6);
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Using bind with pointers to members]
|
||||
|
||||
Pointers to member functions and pointers to data members are not function
|
||||
objects, because they do not support `operator()`. For convenience, `bind`
|
||||
accepts member pointers as its first argument, and the behavior is as if
|
||||
[@boost:/libs/bind/mem_fn.html `boost::mem_fn`] has been used to convert the
|
||||
member pointer into a function object. In other words, the expression
|
||||
|
||||
bind(&X::f, args)
|
||||
|
||||
is equivalent to
|
||||
|
||||
bind<R>(``[@boost:/libs/bind/mem_fn.html `mem_fn`]``(&X::f), args)
|
||||
|
||||
where `R` is the return type of `X::f` (for member functions) or the type of
|
||||
the member (for data members.)
|
||||
|
||||
/[Note:/ `mem_fn` 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 `mem_fn`
|
||||
[@boost:/libs/bind/mem_fn.html documentation]./]/
|
||||
|
||||
Example:
|
||||
|
||||
struct X
|
||||
{
|
||||
bool f(int a);
|
||||
};
|
||||
|
||||
X x;
|
||||
shared_ptr<X> p(new X);
|
||||
int i = 5;
|
||||
|
||||
bind(&X::f, ref(x), _1)(i); // x.f(i)
|
||||
bind(&X::f, &x, _1)(i); // (&x)->f(i)
|
||||
bind(&X::f, x, _1)(i); // (internal copy of x).f(i)
|
||||
bind(&X::f, p, _1)(i); // (internal copy of p)->f(i)
|
||||
|
||||
The last two examples are interesting in that they produce "self-contained"
|
||||
function objects. `bind(&X::f, x, _1)` stores a copy of `x`.
|
||||
`bind(&X::f, p, _1)` stores a copy of `p`, and since `p` is a
|
||||
[@boost:/libs/smart_ptr/shared_ptr.htm `boost::shared_ptr`], the function
|
||||
object retains a reference to its instance of `X` and will remain valid even
|
||||
when `p` goes out of scope or is `reset()`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Using nested binds for function composition]
|
||||
|
||||
Some of the arguments passed to `bind` may be nested /bind expressions/
|
||||
themselves:
|
||||
|
||||
bind(f, bind(g, _1))(x); // f(g(x))
|
||||
|
||||
The inner /bind expressions/ are evaluated, in unspecified order, before the
|
||||
outer `bind` when the function object is called; the results of the evaluation
|
||||
are then substituted in their place when the outer `bind` is evaluated. In the
|
||||
example above, when the function object is called with the argument list `(x)`,
|
||||
`bind(g, _1)(x)` is evaluated first, yielding `g(x)`, and then
|
||||
`bind(f, g(x))(x)` is evaluated, yielding the final result `f(g(x))`.
|
||||
|
||||
This feature of `bind` can be used to perform function composition. See
|
||||
[@../../bind_as_compose.cpp bind_as_compose.cpp] for an example that
|
||||
demonstrates how to use `bind` to achieve similar functionality to
|
||||
[@http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm Boost.Compose].
|
||||
|
||||
Note that the first argument - the bound function object - is not evaluated,
|
||||
even when it's a function object that is produced by `bind` or a /placeholder/
|
||||
argument, so the example below does not work as expected:
|
||||
|
||||
typedef void (*pf)(int);
|
||||
|
||||
std::vector<pf> v;
|
||||
std::for_each(v.begin(), v.end(), bind(_1, 5));
|
||||
|
||||
The desired effect can be achieved via a helper function object `apply` that
|
||||
applies its first argument, as a function object, to the rest of its argument
|
||||
list. For convenience, an implementation of `apply` is provided in the
|
||||
[@../../include/boost/bind/apply.hpp apply.hpp] header file. Here is how the
|
||||
modified version of the previous example looks like:
|
||||
|
||||
typedef void (*pf)(int);
|
||||
|
||||
std::vector<pf> v;
|
||||
std::for_each(v.begin(), v.end(), bind(apply<void>(), _1, 5));
|
||||
|
||||
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 /bind subexpressions/. This can be achieved
|
||||
with the help of another function object, `protect`, that masks the type so
|
||||
that `bind` does not recognize and evaluate it. When called, protect simply
|
||||
forwards the argument list to the other function object unmodified.
|
||||
|
||||
The header [@../../include/boost/bind/protect.hpp protect.hpp] contains an
|
||||
implementation of `protect`. To `protect` a bind function object from
|
||||
evaluation, use `protect(bind(f, ...))`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Overloaded operators (new in Boost 1.33)]
|
||||
|
||||
For convenience, the function objects produced by `bind` overload the logical
|
||||
not operator `!` and the relational and logical operators `==, !=, <, <=, >,
|
||||
>=, &&, ||`.
|
||||
|
||||
`!bind(f, ...)` is equivalent to `bind(logical_not(), bind(f, ...))`, where
|
||||
`logical_not` is a function object that takes one argument `x` and returns
|
||||
`!x`.
|
||||
|
||||
`bind(f, ...) op x`, where _op_ is a relational or logical operator, is
|
||||
equivalent to `bind(relation(), bind(f, ...), x)`, where `relation` is a
|
||||
function object that takes two arguments `a` and `b` and returns `a op b`.
|
||||
|
||||
What this means in practice is that you can conveniently negate the result of
|
||||
`bind`:
|
||||
|
||||
std::remove_if(first, last, !bind(&X::visible, _1)); // remove invisible objects
|
||||
|
||||
and compare the result of `bind` against a value:
|
||||
|
||||
std::find_if(first, last, bind(&X::name, _1) == "Peter");
|
||||
std::find_if(first, last, bind(&X::name, _1) == "Peter" || bind(&X::name, _1) == "Paul");
|
||||
|
||||
against a /placeholder/:
|
||||
|
||||
bind(&X::name, _1) == _2
|
||||
|
||||
or against another /bind expression/:
|
||||
|
||||
std::sort(first, last, bind(&X::name, _1) < bind(&X::name, _2)); // sort by name
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
268
doc/bind/troubleshooting.qbk
Normal file
268
doc/bind/troubleshooting.qbk
Normal file
@@ -0,0 +1,268 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2008 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:troubleshooting Troubleshooting]
|
||||
|
||||
[section Incorrect number of arguments]
|
||||
|
||||
In a `bind(f, a1, a2, ..., aN)` expression, the function object `f` 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
|
||||
`bind()` is invoked:
|
||||
|
||||
int f(int, int);
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(f, 1); // error, f takes two arguments
|
||||
boost::bind(f, 1, 2); // OK
|
||||
}
|
||||
|
||||
A common variation of this error is to forget that member functions have an
|
||||
implicit "this" argument:
|
||||
|
||||
struct X
|
||||
{
|
||||
int f(int);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(&X::f, 1); // error, X::f takes two arguments
|
||||
boost::bind(&X::f, _1, 1); // OK
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section The function object cannot be called with the specified arguments]
|
||||
|
||||
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 `bind.hpp` on a line that looks like:
|
||||
|
||||
return f(a[a1_], a[a2_]);
|
||||
|
||||
An example of this kind of error:
|
||||
|
||||
int f(int);
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(f, "incompatible"); // OK so far, no call
|
||||
boost::bind(f, "incompatible")(); // error, "incompatible" is not an int
|
||||
boost::bind(f, _1); // OK
|
||||
boost::bind(f, _1)("incompatible"); // error, "incompatible" is not an int
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Accessing an argument that does not exist]
|
||||
|
||||
The placeholder `_N` selects the argument at position `N` from the argument
|
||||
list passed at "call time." Naturally, it is an error to attempt to access
|
||||
beyond the end of this list:
|
||||
|
||||
int f(int);
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(f, _1); // OK
|
||||
boost::bind(f, _1)(); // error, there is no argument number 1
|
||||
}
|
||||
|
||||
The error is usually reported in `bind.hpp`, at a line similar to:
|
||||
|
||||
return f(a[a1_]);
|
||||
|
||||
When emulating `std::bind1st(f, a)`, a common mistake of this category is to
|
||||
type `bind(f, a, _2)` instead of the correct `bind(f, a, _1)`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Inappropriate use of `bind(f, ...)`]
|
||||
|
||||
The `bind(f, a1, a2, ..., aN)` [link bind.faq.Q_forms form] causes automatic
|
||||
recognition of the type of `f`. It will not work with arbitrary function
|
||||
objects; `f` must be a function or a member function pointer.
|
||||
|
||||
It is possible to use this form with function objects that define
|
||||
`result_type`, 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.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Inappropriate use of `bind<R>(f, ...)`]
|
||||
|
||||
The `bind<R>(f, a1, a2, ..., aN)` [link bind.faq.Q_forms form] supports
|
||||
arbitrary function objects.
|
||||
|
||||
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.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Binding a nonstandard function]
|
||||
|
||||
By default, the `bind(f, a1, a2, ..., aN)` [link bind.faq.Q_forms form]
|
||||
recognizes "ordinary" C++ functions and function pointers. [link
|
||||
bind.implementation.stdcall Functions that use a different calling convention],
|
||||
or variable-argument functions such as `std::printf`, do not work. The general
|
||||
`bind<R>(f, a1, a2, ..., aN)` [link bind.faq.Q_forms form] works with
|
||||
nonstandard functions.
|
||||
|
||||
On some platforms, extern "C" functions, like `std::strcmp`, are not
|
||||
recognized by the short form of `bind`.
|
||||
|
||||
See also [link bind.implementation.stdcall `__stdcall` and `pascal` Support].
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Binding an overloaded function]
|
||||
|
||||
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 in
|
||||
this simplified example:
|
||||
|
||||
struct X
|
||||
{
|
||||
int& get();
|
||||
int const& get() const;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(&X::get, _1);
|
||||
}
|
||||
|
||||
The ambiguity can be resolved manually by casting the (member) function
|
||||
pointer to the desired type:
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(static_cast< int const& (X::*) () const >(&X::get), _1);
|
||||
}
|
||||
|
||||
Another, arguably more readable, alternative is to introduce a temporary
|
||||
variable:
|
||||
|
||||
int main()
|
||||
{
|
||||
int const& (X::*get) () const = &X::get;
|
||||
boost::bind(get, _1);
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Modeling STL function object concepts]
|
||||
|
||||
The function objects that are produced by `bind` do not model the STL
|
||||
[@http://www.sgi.com/tech/stl/UnaryFunction.html /Unary Function/] or
|
||||
[@http://www.sgi.com/tech/stl/BinaryFunction.html /Binary Function/] concepts,
|
||||
even when the function objects are unary or binary operations, because the
|
||||
function object types are missing public typedefs `result_type` and
|
||||
`argument_type` or `first_argument_type` and `second_argument_type`. In cases
|
||||
where these typedefs are desirable, however, the utility function
|
||||
`make_adaptable` can be used to adapt unary and binary function objects to
|
||||
these concepts. This allows unary and binary function objects resulting from
|
||||
`bind` to be combined with STL templates such as
|
||||
[@http://en.cppreference.com/w/cpp/utility/functional/unary_negate `std::unary_negate`]
|
||||
and [@http://en.cppreference.com/w/cpp/utility/functional/binary_negate `std::binary_negate`].
|
||||
|
||||
The `make_adaptable` function is defined in [@../../include/boost/bind/make_adaptable.hpp
|
||||
`<boost/bind/make_adaptable.hpp>`], which must be included explicitly in
|
||||
addition to [@../../include/boost/bind.hpp `<boost/bind.hpp>`]:
|
||||
|
||||
#include <boost/bind/make_adaptable.hpp>
|
||||
|
||||
template <class R, class F> ``/unspecified-type/`` make_adaptable(F f);
|
||||
|
||||
template<class R, class A1, class F> ``/unspecified-unary-functional-type/`` make_adaptable(F f);
|
||||
|
||||
template<class R, class A1, class A2, class F> ``/unspecified-binary-functional-type/`` make_adaptable(F f);
|
||||
|
||||
template<class R, class A1, class A2, class A3, class F> ``/unspecified-ternary-functional-type/`` make_adaptable(F f);
|
||||
|
||||
template<class R, class A1, class A2, class A3, class A4, class F> ``/unspecified-4-ary-functional-type/`` make_adaptable(F f);
|
||||
|
||||
This example shows how to use `make_adaptable` to make a predicate for "is not a space":
|
||||
|
||||
typedef char char_t;
|
||||
std::locale loc("");
|
||||
const std::ctype<char_t>& ct = std::use_facet<std::ctype<char_t> >(loc);
|
||||
|
||||
auto isntspace = std::not1(boost::make_adaptable<bool, char_t>(boost::bind(&std::ctype<char_t>::is, &ct, std::ctype_base::space, _1)));
|
||||
|
||||
In this example, `bind` creates the "is a space" (unary) predicate. It is then
|
||||
passed to `make_adaptable` so that a function object modeling the /Unary
|
||||
Function/ concept can be created, serving as the argument to
|
||||
[@http://en.cppreference.com/w/cpp/utility/functional/not1 `std::not1`].
|
||||
|
||||
[endsect]
|
||||
|
||||
[section `const` in signatures]
|
||||
|
||||
Some compilers, including MSVC 6.0 and Borland C++ 5.5.1, have problems with
|
||||
the top-level `const` in function signatures:
|
||||
|
||||
int f(int const);
|
||||
|
||||
int main()
|
||||
{
|
||||
boost::bind(f, 1); // error
|
||||
}
|
||||
|
||||
Workaround: remove the `const` qualifier from the argument.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section MSVC specific: `using boost::bind;`]
|
||||
|
||||
On MSVC (up to version 7.0), when `boostbind` is brought into scope with an
|
||||
using declaration:
|
||||
|
||||
using boost::bind;
|
||||
|
||||
the syntax `bind<R>(f, ...)` does not work. Workaround: either use the
|
||||
qualified name, `boost::bind`, or use an using directive instead:
|
||||
|
||||
using namespace boost;
|
||||
|
||||
[endsect]
|
||||
|
||||
[section MSVC specific: class templates shadow function templates]
|
||||
|
||||
On MSVC (up to version 7.0), a nested class template named `bind` will shadow
|
||||
the function template `boost::bind`, breaking the `bind<R>(f, ...)`syntax.
|
||||
Unfortunately, some libraries contain nested class templates named `bind`
|
||||
(ironically, such code is often an MSVC specific workaround.)
|
||||
|
||||
The workaround is to use the alternative `bind(type<R>(), f, ...)` syntax.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section MSVC specific: `...` in signatures treated as type]
|
||||
|
||||
MSVC (up to version 7.0) treats the ellipsis in a variable argument function
|
||||
(such as `std::printf`) as a type. Therefore, it will accept the (incorrect in
|
||||
the current implementation) form:
|
||||
|
||||
bind(printf, "%s\n", _1);
|
||||
|
||||
and will reject the correct version:
|
||||
|
||||
bind<int>(printf, "%s\n", _1);
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
32
doc/mem_fn.qbk
Normal file
32
doc/mem_fn.qbk
Normal file
@@ -0,0 +1,32 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2005 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[library Boost.Member Function
|
||||
[quickbook 1.6]
|
||||
[id mem_fn]
|
||||
[copyright 2001, 2002 Peter Dimov and Multi Media Ltd.]
|
||||
[copyright 2003-2005 Peter Dimov]
|
||||
[dirname bind]
|
||||
[license Distributed under the
|
||||
[@http://boost.org/LICENSE_1_0.txt Boost Software License,
|
||||
Version 1.0].
|
||||
]
|
||||
]
|
||||
|
||||
[template simplesect[title]
|
||||
[block '''<simplesect><title>'''[title]'''</title>''']]
|
||||
|
||||
[template endsimplesect[]
|
||||
[block '''</simplesect>''']]
|
||||
|
||||
[include mem_fn/purpose.qbk]
|
||||
[include mem_fn/faq.qbk]
|
||||
[include mem_fn/interface.qbk]
|
||||
[include mem_fn/implementation.qbk]
|
||||
[include mem_fn/acknowledgements.qbk]
|
||||
28
doc/mem_fn/acknowledgements.qbk
Normal file
28
doc/mem_fn/acknowledgements.qbk
Normal file
@@ -0,0 +1,28 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2005 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:acknowledgements Acknowledgements]
|
||||
|
||||
* Rene Jager's initial suggestion of using traits classes to make `mem_fn`
|
||||
adapt to user-defined smart pointers inspired the `get_pointer`-based design.
|
||||
|
||||
* Numerous improvements were suggested during the formal review period by
|
||||
Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was Darin
|
||||
Adler.
|
||||
|
||||
* Steve Anichini pointed out that COM interfaces use `__stdcall`.
|
||||
|
||||
* Dave Abrahams modified `bind` and `mem_fn` to support `void` returns on
|
||||
deficient compilers.
|
||||
|
||||
* Daniel Boelzle pointed out that UDK uses `__cdecl`.
|
||||
|
||||
This documentation was ported to Quickbook by Agustín Bergé.
|
||||
|
||||
[endsect]
|
||||
53
doc/mem_fn/faq.qbk
Normal file
53
doc/mem_fn/faq.qbk
Normal file
@@ -0,0 +1,53 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2005 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:faq Frequently Asked Questions]
|
||||
|
||||
[section Can `mem_fn` be used instead of the standard `std::mem_fun[_ref]`
|
||||
adaptors?]
|
||||
|
||||
Yes. For simple uses, `mem_fn` provides additional functionality that the
|
||||
standard adaptors do not. Complicated expressions that use `std::bind1st`,
|
||||
`std::bind2nd` or [@http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm Boost.Compose]
|
||||
along with the standard adaptors can be rewritten using `boost::bind` that
|
||||
automatically takes advantage of `mem_fn`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Should I replace every occurence of `std::mem_fun[_ref]` with
|
||||
`mem_fn` in my existing code?]
|
||||
|
||||
No, unless you have good reasons to do so. `mem_fn` is not 100% compatible
|
||||
with the standard adaptors, although it comes pretty close. In particular,
|
||||
`mem_fn` does not return objects of type `std::[const_]mem_fun[1][_ref]_t`, as
|
||||
the standard adaptors do, and it is not possible to fully describe the type of
|
||||
the first argument using the standard `argument_type` and `first_argument_type`
|
||||
nested typedefs. Libraries that need adaptable function objects in order to
|
||||
function might not like `mem_fn`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Does `mem_fn` work with COM methods?]
|
||||
|
||||
Yes, if you [link mem_fn.implementation.stdcall `#define BOOST_MEM_FN_ENABLE_STDCALL].
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Why isn't `BOOST_MEM_FN_ENABLE_STDCALL` defined automatically?]
|
||||
|
||||
Non-portable extensions, in general, should default to off to prevent vendor
|
||||
lock-in. Had `BOOST_MEM_FN_ENABLE_STDCALL` been defined automatically, you
|
||||
could have accidentally taken advantage of it without realizing that your code
|
||||
is, perhaps, no longer portable. In addition, it is possible for the default
|
||||
calling convention to be `__stdcall`, in which case enabling `__stdcall`
|
||||
support will result in duplicate definitions.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
70
doc/mem_fn/implementation.qbk
Normal file
70
doc/mem_fn/implementation.qbk
Normal file
@@ -0,0 +1,70 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2005 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:implementation Implementation]
|
||||
|
||||
[section Files]
|
||||
|
||||
* [@../../include/boost/mem_fn.hpp boost/mem_fn.hpp] (main header)
|
||||
* [@../../include/boost/bind/mem_fn_cc.hpp boost/bind/mem_fn_cc.hpp] (used by `mem_fn.hpp`, do not include directly)
|
||||
* [@../../include/boost/bind/mem_fn_vw.hpp boost/bind/mem_fn_vw.hpp] (used by `mem_fn.hpp`, do not include directly)
|
||||
* [@../../include/boost/bind/mem_fn_template.hpp boost/bind/mem_fn_template.hpp] (used by `mem_fn.hpp`, do not include directly)
|
||||
* [@../../test/mem_fn_test.cpp libs/bind/test/mem_fn_test.cpp] (test)
|
||||
* [@../../test/mem_fn_derived_test.cpp libs/bind/test/mem_fn_derived_test.cpp] (test with derived objects)
|
||||
* [@../../test/mem_fn_fastcall_test.cpp libs/bind/test/mem_fn_fastcall_test.cpp] (test for `__fastcall`)
|
||||
* [@../../test/mem_fn_stdcall_test.cpp libs/bind/test/mem_fn_stdcall_test.cpp] (test for `__stdcall`)
|
||||
* [@../../test/mem_fn_void_test.cpp libs/bind/test/mem_fn_void_test.cpp] (test for `void` returns)
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Dependencies]
|
||||
|
||||
* [@boost:/libs/config/config.htm Boost.Config]
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Number of Arguments]
|
||||
|
||||
This implementation supports member functions with up to eight arguments. This
|
||||
is not an inherent limitation of the design, but an implementation detail.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section:stdcall `__stdcall`, `__cdecl`, and `__fastcall` Support]
|
||||
|
||||
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.)
|
||||
|
||||
For example, Windows API functions and COM interface member functions use a
|
||||
calling convention known as `__stdcall`. Borland VCL components use
|
||||
`__fastcall`. UDK, the component model of OpenOffice.org, uses `__cdecl`.
|
||||
|
||||
To use `mem_fn` with `__stdcall` member functions, `#define` the macro
|
||||
`BOOST_MEM_FN_ENABLE_STDCALL` before including `<boost/mem_fn.hpp>`.
|
||||
|
||||
To use `mem_fn` with `__fastcall` member functions, `#define` the macro
|
||||
`BOOST_MEM_FN_ENABLE_FASTCALL` before including `<boost/mem_fn.hpp>`.
|
||||
|
||||
To use `mem_fn` with `__cdecl` member functions, `#define` the macro
|
||||
`BOOST_MEM_FN_ENABLE_CDECL` before including `<boost/mem_fn.hpp>`.
|
||||
|
||||
[*It is best to define these macros in the project options, via `-D` on the
|
||||
command line, or as the first line in the translation unit (.cpp file) where
|
||||
`mem_fn` is used.] Not following this rule can lead to obscure errors when a
|
||||
header includes `mem_fn.hpp` before the macro has been defined.
|
||||
|
||||
/[Note:/ this is a non-portable extension. It is not part of the interface./]/
|
||||
|
||||
/[Note:/ Some compilers provide only minimal support for the `__stdcall` keyword./]/
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
133
doc/mem_fn/interface.qbk
Normal file
133
doc/mem_fn/interface.qbk
Normal file
@@ -0,0 +1,133 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2005 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:interface Interface]
|
||||
|
||||
[section:synopsys Synopsis]
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template<class T> T * ``[link get_pointer_1 `get_pointer`]``(T * p);
|
||||
|
||||
template<class R, class T> ``/unspecified-1/`` ``[link mem_fn_1 `mem_fn`]``(R (T::*pmf) ());
|
||||
|
||||
template<class R, class T> ``/unspecified-2/`` ``[link mem_fn_2 `mem_fn`]``(R (T::*pmf) () const);
|
||||
|
||||
template<class R, class T> ``/unspecified-2-1/`` ``[link mem_fn_2_1 `mem_fn`]``(R T::*pm);
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-3/`` ``[link mem_fn_3 `mem_fn`]``(R (T::*pmf) (A1));
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-4/`` ``[link mem_fn_4 `mem_fn`]``(R (T::*pmf) (A1) const);
|
||||
|
||||
template<class R, class T, class A1, class A2> ``/unspecified-5/`` ``[link mem_fn_5 `mem_fn`]``(R (T::*pmf) (A1, A2));
|
||||
|
||||
template<class R, class T, class A1, class A2> ``/unspecified-6/`` ``[link mem_fn_6 `mem_fn`]``(R (T::*pmf) (A1, A2) const);
|
||||
|
||||
// implementation defined number of additional overloads for more arguments
|
||||
}
|
||||
|
||||
[endsect]
|
||||
|
||||
[section Common requirements]
|
||||
|
||||
All /unspecified-N/ types mentioned in the Synopsis are /CopyConstructible/
|
||||
and /Assignable/. Their copy constructors and assignment operators do not
|
||||
throw exceptions. /unspecified-N/`::result_type` is defined as the return type
|
||||
of the member function pointer passed as an argument to `mem_fn` (`R` in the
|
||||
Synopsis.) /unspecified-2-1/`::result_type` is defined as `R`.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section `get_pointer`]
|
||||
|
||||
[#get_pointer_1]
|
||||
|
||||
template<class T> T * get_pointer(T * p)
|
||||
|
||||
* /Returns:/ `p`.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[endsect]
|
||||
|
||||
[section `mem_fn`]
|
||||
|
||||
[#mem_fn_1]
|
||||
|
||||
template<class R, class T> ``/unspecified-1/`` mem_fn(R (T::*pmf) ())
|
||||
|
||||
* /Returns:/ a function object \u03DD such that the expression \u03DD`(t)` is
|
||||
equivalent to `(t.*pmf)()` when `t` is an l-value of type `T` or derived,
|
||||
`(get_pointer(t)->*pmf)()` otherwise.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[#mem_fn_2]
|
||||
|
||||
template<class R, class T> ``/unspecified-2/`` mem_fn(R (T::*pmf) () const)
|
||||
|
||||
* /Returns:/ a function object \u03DD such that the expression \u03DD`(t)` is
|
||||
equivalent to `(t.*pmf)()` when `t` is of type `T` /[/`const`/]/ or derived,
|
||||
`(get_pointer(t)->*pmf)()` otherwise.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[#mem_fn_2_1]
|
||||
|
||||
template<class R, class T> ``/unspecified-2-1/`` mem_fn(R T::*pm)
|
||||
|
||||
* /Returns:/ a function object \u03DD such that the expression \u03DD`(t)` is
|
||||
equivalent to `t.*pm` when `t` is of type `T` /[/`const`/]/ or derived,
|
||||
`get_pointer(t)->*pm` otherwise.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[#mem_fn_3]
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-3/`` mem_fn(R (T::*pmf) (A1))
|
||||
|
||||
* /Returns:/ a function object \u03DD such that the expression \u03DD`(t, a1)`
|
||||
is equivalent to `(t.*pmf)(a1)` when `t` is an l-value of type `T` or derived,
|
||||
`(get_pointer(t)->*pmf)(a1)` otherwise.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[#mem_fn_4]
|
||||
|
||||
template<class R, class T, class A1> ``/unspecified-4/`` mem_fn(R (T::*pmf) (A1) const)
|
||||
|
||||
* /Returns:/ a function object \u03DD such that the expression \u03DD`(t, a1)`
|
||||
is equivalent to `(t.*pmf)(a1)` when `t` is of type `T` /[/`const`/]/ or derived,
|
||||
`(get_pointer(t)->*pmf)(a1)` otherwise.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[#mem_fn_5]
|
||||
|
||||
template<class R, class T, class A1, class A2> ``/unspecified-5/`` mem_fn(R (T::*pmf) (A1, A2))
|
||||
|
||||
* /Returns:/ a function object \u03DD such that the expression \u03DD`(t, a1, a2)`
|
||||
is equivalent to `(t.*pmf)(a1, a2)` when `t` is an l-value of type `T` or derived,
|
||||
`(get_pointer(t)->*pmf)(a1, a2)` otherwise.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[#mem_fn_6]
|
||||
|
||||
template<class R, class T, class A1, class A2> ``/unspecified-6/`` mem_fn(R (T::*pmf) (A1, A2) const)
|
||||
|
||||
* /Returns:/ a function object \u03DD such that the expression \u03DD`(t, a1, a2)`
|
||||
is equivalent to `(t.*pmf)(a1, a2)` when `t` is of type `T` /[/`const`/]/ or derived,
|
||||
`(get_pointer(t)->*pmf)(a1, a2)` otherwise.
|
||||
|
||||
* /Throws:/ Nothing.
|
||||
|
||||
[endsect]
|
||||
|
||||
[endsect]
|
||||
93
doc/mem_fn/purpose.qbk
Normal file
93
doc/mem_fn/purpose.qbk
Normal file
@@ -0,0 +1,93 @@
|
||||
[/
|
||||
/ Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
||||
/ Copyright (c) 2003-2005 Peter Dimov
|
||||
/
|
||||
/ Distributed under the Boost Software License, Version 1.0. (See
|
||||
/ accompanying file LICENSE_1_0.txt or copy at
|
||||
/ http://www.boost.org/LICENSE_1_0.txt)
|
||||
/]
|
||||
|
||||
[section:purpose Purpose]
|
||||
|
||||
`boost::mem_fn` is a generalization of the standard functions `std::mem_fun`
|
||||
and `std::mem_fun_ref`. It supports member function pointers with more than
|
||||
one argument, and the returned function object can take a pointer, a
|
||||
reference, or a smart pointer to an object instance as its first argument.
|
||||
`mem_fn` also supports pointers to data members by treating them as functions
|
||||
taking no arguments and returning a (const) reference to the member.
|
||||
|
||||
The purpose of `mem_fn` is twofold. First, it allows users to invoke a member
|
||||
function on a container with the familiar
|
||||
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&Shape::draw));
|
||||
|
||||
syntax, even when the container stores smart pointers.
|
||||
|
||||
Second, it can be used as a building block by library developers that want to
|
||||
treat a pointer to member function as a function object. A library might
|
||||
define an enhanced `for_each` algorithm with an overload of the form:
|
||||
|
||||
template<class It, class R, class T> void for_each(It first, It last, R (T::*pmf) ())
|
||||
{
|
||||
std::for_each(first, last, boost::mem_fn(pmf));
|
||||
}
|
||||
|
||||
that will allow the convenient syntax:
|
||||
|
||||
for_each(v.begin(), v.end(), &Shape::draw);
|
||||
|
||||
When documenting the feature, the library author will simply state:
|
||||
|
||||
template<class It, class R, class T> void for_each(It first, It last, R (T::*pmf) ());
|
||||
|
||||
* /Effects:/ Equivalent to `std::for_each(first, last, boost::mem_fn(pmf))`.
|
||||
|
||||
where `boost::mem_fn` can be a link to this page. See the
|
||||
[@boost:/libs/bind/bind.html documentation of `bind`] for an example.
|
||||
|
||||
`mem_fn` takes one argument, a pointer to a member, and returns a function
|
||||
object suitable for use with standard or user-defined algorithms:
|
||||
|
||||
struct X
|
||||
{
|
||||
void f();
|
||||
};
|
||||
|
||||
void g(std::vector<X> & v)
|
||||
{
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
|
||||
};
|
||||
|
||||
void h(std::vector<X *> const & v)
|
||||
{
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
|
||||
};
|
||||
|
||||
void k(std::vector<boost::shared_ptr<X> > const & v)
|
||||
{
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
|
||||
};
|
||||
|
||||
The returned function object takes the same arguments as the input member
|
||||
function plus a "flexible" first argument that represents the object instance.
|
||||
|
||||
When the function object is invoked with a first argument `x` that is neither
|
||||
a pointer nor a reference to the appropriate class (`X` in the example above),
|
||||
it uses `get_pointer(x)` to obtain a pointer from `x`. Library authors can
|
||||
"register" their smart pointer classes by supplying an appropriate
|
||||
`get_pointer` overload, allowing `mem_fn` to recognize and support them.
|
||||
|
||||
|
||||
/[Note:/ `get_pointer` is not restricted to return a pointer. Any object that
|
||||
can be used in a member function call expression `(x->*pmf)(...)` will work./]/
|
||||
|
||||
/[Note:/ the library uses an unqualified call to `get_pointer`. Therefore, it
|
||||
will find, through argument-dependent lookup, `get_pointer` overloads that are
|
||||
defined in the same namespace as the corresponding smart pointer class, in
|
||||
addition to any `boost::get_pointer` overloads./]/
|
||||
|
||||
All function objects returned by `mem_fn` expose a `result_type` typedef that
|
||||
represents the return type of the member function. For data members,
|
||||
`result_type` is defined as the type of the member.
|
||||
|
||||
[endsect]
|
||||
@@ -34,6 +34,26 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class A1>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
|
||||
typedef typename _bi::list_av_1<A1>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class A1>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
|
||||
typedef typename _bi::list_av_1<A1>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
|
||||
}
|
||||
|
||||
// 1
|
||||
|
||||
template<class R, class T,
|
||||
@@ -58,6 +78,28 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1,
|
||||
class A1, class A2>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
|
||||
typedef typename _bi::list_av_2<A1, A2>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1,
|
||||
class A1, class A2>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
|
||||
typedef typename _bi::list_av_2<A1, A2>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
|
||||
}
|
||||
|
||||
// 2
|
||||
|
||||
template<class R, class T,
|
||||
@@ -82,6 +124,28 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2,
|
||||
class A1, class A2, class A3>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
|
||||
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2,
|
||||
class A1, class A2, class A3>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
|
||||
typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
|
||||
}
|
||||
|
||||
// 3
|
||||
|
||||
template<class R, class T,
|
||||
@@ -106,6 +170,28 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3,
|
||||
class A1, class A2, class A3, class A4>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
|
||||
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3,
|
||||
class A1, class A2, class A3, class A4>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
|
||||
typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
|
||||
}
|
||||
|
||||
// 4
|
||||
|
||||
template<class R, class T,
|
||||
@@ -130,6 +216,28 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4,
|
||||
class A1, class A2, class A3, class A4, class A5>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
|
||||
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4,
|
||||
class A1, class A2, class A3, class A4, class A5>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
|
||||
typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
|
||||
}
|
||||
|
||||
// 5
|
||||
|
||||
template<class R, class T,
|
||||
@@ -154,6 +262,28 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
|
||||
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
|
||||
typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
|
||||
}
|
||||
|
||||
// 6
|
||||
|
||||
template<class R, class T,
|
||||
@@ -178,6 +308,28 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5, class B6,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
|
||||
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5, class B6,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
|
||||
typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
|
||||
}
|
||||
|
||||
// 7
|
||||
|
||||
template<class R, class T,
|
||||
@@ -202,6 +354,28 @@ template<class R, class T,
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
|
||||
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5, class B6, class B7,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
|
||||
typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
|
||||
}
|
||||
|
||||
// 8
|
||||
|
||||
template<class R, class T,
|
||||
@@ -225,3 +399,25 @@ template<class R, class T,
|
||||
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
|
||||
return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
|
||||
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
|
||||
}
|
||||
|
||||
template<class Rt2, class R, class T,
|
||||
class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
|
||||
class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
_bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
|
||||
BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
|
||||
{
|
||||
typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
|
||||
typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
|
||||
return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
|
||||
}
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
<html>
|
||||
<head>
|
||||
<meta http-equiv="refresh" content="0; URL=bind.html">
|
||||
<meta http-equiv="refresh" content="0; URL=doc/html/bind.html">
|
||||
</head>
|
||||
<body>
|
||||
Automatic redirection failed, please go to
|
||||
<a href="bind.html">bind.html</a> or
|
||||
<a href="mem_fn.html">mem_fn.html</a>.
|
||||
<a href="doc/html/bind.html">doc/html/bind.html</a> or
|
||||
<a href="doc/html/mem_fn.html">doc/html/mem_fn.html</a>.
|
||||
</body>
|
||||
</html>
|
||||
<!--
|
||||
|
||||
421
mem_fn.html
421
mem_fn.html
@@ -1,405 +1,28 @@
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Boost: mem_fn.hpp documentation</title>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||
</head>
|
||||
<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
|
||||
<table border="0" width="100%">
|
||||
<tr>
|
||||
<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
|
||||
</td>
|
||||
<td align="center">
|
||||
<h1>mem_fn.hpp</h1>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td colspan="2" height="64"> </td>
|
||||
</tr>
|
||||
</table>
|
||||
<h2>Contents</h2>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><a href="#Purpose">Purpose</a></h3>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><a href="#FAQ">Frequently Asked Questions</a></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Q1">Can <b>mem_fn</b> be used instead of the
|
||||
standard <b>std::mem_fun[_ref]</b> adaptors?</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b>
|
||||
with <b>mem_fn</b> in my existing code?</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Q3">Does <b>mem_fn</b> work with COM methods?</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL
|
||||
defined automatically?</a></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><a href="#Interface">Interface</a></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Synopsis">Synopsis</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#CommonRequirements">Common requirements</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#get_pointer">get_pointer</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#mem_fn">mem_fn</a></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><a href="#Implementation">Implementation</a></h3>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Files">Files</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#Dependencies">Dependencies</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#NumberOfArguments">Number of Arguments</a></h4>
|
||||
<h4 style="MARGIN-LEFT: 40pt"><a href="#stdcall">"__stdcall", "__cdecl" and
|
||||
"__fastcall" Support</a></h4>
|
||||
<h3 style="MARGIN-LEFT: 20pt"><a href="#Acknowledgements">Acknowledgements</a></h3>
|
||||
<h2><a name="Purpose">Purpose</a></h2>
|
||||
<head>
|
||||
<title>Boost.MemberFunction</title>
|
||||
<meta charset="utf-8">
|
||||
<meta http-equiv="refresh" content="0; url=doc/html/mem_fn.html">
|
||||
<style>
|
||||
body {
|
||||
background: #fff;
|
||||
color: #000;
|
||||
}
|
||||
a {
|
||||
color: #00f;
|
||||
text-decoration: none;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<p>
|
||||
<b>boost::mem_fn</b> is a generalization of the standard functions <b>std::mem_fun</b>
|
||||
and <b>std::mem_fun_ref</b>. It supports member function pointers with more
|
||||
than one argument, and the returned function object can take a pointer, a
|
||||
reference, or a smart pointer to an object instance as its first argument. <STRONG>mem_fn</STRONG>
|
||||
also supports pointers to data members by treating them as functions taking no
|
||||
arguments and returning a (const) reference to the member.
|
||||
Automatic redirection failed, please go to
|
||||
<a href="doc/html/mem_fn.html">doc/html/mem_fn.html</a>
|
||||
</p>
|
||||
<p>
|
||||
The purpose of <b>mem_fn</b> is twofold. First, it allows users to invoke a
|
||||
member function on a container with the familiar
|
||||
© 2001, 2002 Peter Dimov and Multi Media Ltd.<br>
|
||||
© 2003-2005 Peter Dimov
|
||||
</p>
|
||||
<pre>
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&Shape::draw));
|
||||
</pre>
|
||||
<p>
|
||||
syntax, even when the container stores smart pointers.
|
||||
</p>
|
||||
<p>
|
||||
Second, it can be used as a building block by library developers that want to
|
||||
treat a pointer to member function as a function object. A library might define
|
||||
an enhanced <b>for_each</b> algorithm with an overload of the form:
|
||||
</p>
|
||||
<pre>
|
||||
template<class It, class R, class T> void for_each(It first, It last, R (T::*pmf) ())
|
||||
{
|
||||
std::for_each(first, last, boost::mem_fn(pmf));
|
||||
}
|
||||
</pre>
|
||||
<p>
|
||||
that will allow the convenient syntax:
|
||||
</p>
|
||||
<pre>
|
||||
for_each(v.begin(), v.end(), &Shape::draw);
|
||||
</pre>
|
||||
<p>
|
||||
When documenting the feature, the library author will simply state:
|
||||
</p>
|
||||
<h4 style="MARGIN-LEFT: 20pt">template<class It, class R, class T> void
|
||||
for_each(It first, It last, R (T::*pmf) ());</h4>
|
||||
<p style="MARGIN-LEFT: 20pt">
|
||||
<b>Effects:</b> equivalent to std::for_each(first, last, boost::mem_fn(pmf));
|
||||
</p>
|
||||
<p>
|
||||
where <b>boost::mem_fn</b> can be a link to this page. See <a href="bind.html">the
|
||||
documentation of <b>bind</b></a> for an example.
|
||||
</p>
|
||||
<p>
|
||||
<b>mem_fn</b> takes one argument, a pointer to a member, and returns a function
|
||||
object suitable for use with standard or user-defined algorithms:
|
||||
</p>
|
||||
<pre>
|
||||
struct X
|
||||
{
|
||||
void f();
|
||||
};
|
||||
|
||||
void g(std::vector<X> & v)
|
||||
{
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
|
||||
};
|
||||
|
||||
void h(std::vector<X *> const & v)
|
||||
{
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
|
||||
};
|
||||
|
||||
void k(std::vector<boost::shared_ptr<X> > const & v)
|
||||
{
|
||||
std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
|
||||
};
|
||||
</pre>
|
||||
<p>
|
||||
The returned function object takes the same arguments as the input member
|
||||
function plus a "flexible" first argument that represents the object instance.
|
||||
</p>
|
||||
<p>
|
||||
When the function object is invoked with a first argument <b>x</b> that is
|
||||
neither a pointer nor a reference to the appropriate class (<b>X</b> in the
|
||||
example above), it uses <tt>get_pointer(x)</tt> to obtain a pointer from <b>x</b>.
|
||||
Library authors can "register" their smart pointer classes by supplying an
|
||||
appropriate <b>get_pointer</b> overload, allowing <b>mem_fn</b> to recognize
|
||||
and support them.
|
||||
</p>
|
||||
<p>
|
||||
[Note: <b>get_pointer</b> is not restricted to return a pointer. Any object
|
||||
that can be used in a member function call expression <tt>(x->*pmf)(...)</tt>
|
||||
will work.]
|
||||
</p>
|
||||
<p>
|
||||
[Note: the library uses an unqualified call to <b>get_pointer</b>. Therefore,
|
||||
it will find, through argument-dependent lookup, <b>get_pointer</b> overloads
|
||||
that are defined in the same namespace as the corresponding smart pointer
|
||||
class, in addition to any <b>boost::get_pointer</b> overloads.]
|
||||
</p>
|
||||
<p>
|
||||
All function objects returned by <b>mem_fn</b> expose a <b>result_type</b> typedef
|
||||
that represents the return type of the member function. For data members, <STRONG>result_type</STRONG>
|
||||
is defined as the type of the member.
|
||||
</p>
|
||||
<h2><a name="FAQ">Frequently Asked Questions</a></h2>
|
||||
<h3><a name="Q1">Can <b>mem_fn</b> be used instead of the standard <b>std::mem_fun[_ref]</b>
|
||||
adaptors?</a></h3>
|
||||
<p>
|
||||
Yes. For simple uses, <b>mem_fn</b> provides additional functionality that the
|
||||
standard adaptors do not. Complicated expressions that use <b>std::bind1st</b>, <b>std::bind2nd</b>
|
||||
or <a href="http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm"><b>Boost.Compose</b></a> along with the
|
||||
standard adaptors can be rewritten using <a href="bind.html"><b>boost::bind</b></a>
|
||||
that automatically takes advantage of <b>mem_fn</b>.
|
||||
</p>
|
||||
<h3><a name="Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b> with <b>mem_fn</b>
|
||||
in my existing code?</a></h3>
|
||||
<p>
|
||||
No, unless you have good reasons to do so. <b>mem_fn</b> is not 100% compatible
|
||||
with the standard adaptors, although it comes pretty close. In particular, <b>mem_fn</b>
|
||||
does not return objects of type <b>std::[const_]mem_fun[1][_ref]_t</b>, as the
|
||||
standard adaptors do, and it is not possible to fully describe the type of the
|
||||
first argument using the standard <b>argument_type</b> and <b>first_argument_type</b>
|
||||
nested typedefs. Libraries that need adaptable function objects in order to
|
||||
function might not like <b>mem_fn</b>.
|
||||
</p>
|
||||
<h3><a name="Q3">Does <b>mem_fn</b> work with COM methods?</a></h3>
|
||||
<p>
|
||||
Yes, if you <a href="#stdcall">#define BOOST_MEM_FN_ENABLE_STDCALL</a>.
|
||||
</p>
|
||||
<h3><a name="Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL defined automatically?</a></h3>
|
||||
<p>
|
||||
Non-portable extensions, in general, should default to off to prevent vendor
|
||||
lock-in. Had BOOST_MEM_FN_ENABLE_STDCALL been defined automatically, you could
|
||||
have accidentally taken advantage of it without realizing that your code is,
|
||||
perhaps, no longer portable. In addition, it is possible for the default
|
||||
calling convention to be __stdcall, in which case enabling __stdcall support
|
||||
will result in duplicate definitions.
|
||||
</p>
|
||||
<h2><a name="Interface">Interface</a></h2>
|
||||
<h3><a name="Synopsis">Synopsis</a></h3>
|
||||
<pre>
|
||||
namespace boost
|
||||
{
|
||||
|
||||
template<class T> T * <a href="#get_pointer_1">get_pointer</a>(T * p);
|
||||
|
||||
template<class R, class T> <i>unspecified-1</i> <a href="#mem_fn_1">mem_fn</a>(R (T::*pmf) ());
|
||||
|
||||
template<class R, class T> <i>unspecified-2</i> <a href="#mem_fn_2">mem_fn</a>(R (T::*pmf) () const);
|
||||
|
||||
template<class R, class T> <i>unspecified-2-1</i> <a href="#mem_fn_2_1">mem_fn</a>(R T::*pm);
|
||||
|
||||
template<class R, class T, class A1> <i>unspecified-3</i> <a href="#mem_fn_3">mem_fn</a>(R (T::*pmf) (A1));
|
||||
|
||||
template<class R, class T, class A1> <i>unspecified-4</i> <a href="#mem_fn_4">mem_fn</a>(R (T::*pmf) (A1) const);
|
||||
|
||||
template<class R, class T, class A1, class A2> <i>unspecified-5</i> <a href="#mem_fn_5">mem_fn</a>(R (T::*pmf) (A1, A2));
|
||||
|
||||
template<class R, class T, class A1, class A2> <i>unspecified-6</i> <a href="#mem_fn_6">mem_fn</a>(R (T::*pmf) (A1, A2) const);
|
||||
|
||||
// implementation defined number of additional overloads for more arguments
|
||||
|
||||
}
|
||||
</pre>
|
||||
<h3><a name="CommonRequirements">Common requirements</a></h3>
|
||||
<p>
|
||||
All <tt><i>unspecified-N</i></tt> types mentioned in the Synopsis are <b>CopyConstructible</b>
|
||||
and <b>Assignable</b>. Their copy constructors and assignment operators do not
|
||||
throw exceptions. <tt><i>unspecified-N</i>::result_type</tt> is defined as the
|
||||
return type of the member function pointer passed as an argument to <b>mem_fn</b>
|
||||
(<b>R</b> in the Synopsis.) <tt><i>unspecified-2-1</i>::result_type</tt> is
|
||||
defined as <tt>R</tt>.
|
||||
</p>
|
||||
<h3><a name="get_pointer">get_pointer</a></h3>
|
||||
<h4><a name="get_pointer_1">template<class T> T * get_pointer(T * p)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> <tt>p</tt>.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h3><a name="mem_fn">mem_fn</a></h3>
|
||||
<h4><a name="mem_fn_1">template<class R, class T> <i>unspecified-1</i> mem_fn(R
|
||||
(T::*pmf) ())</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
|
||||
is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is an l-value of type <STRONG>T </STRONG>
|
||||
or derived, <tt>(get_pointer(t)->*pmf)()</tt> otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_2">template<class R, class T> <i>unspecified-2</i> mem_fn(R
|
||||
(T::*pmf) () const)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
|
||||
is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is of type <STRONG>T</STRONG>
|
||||
<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)->*pmf)()</tt>
|
||||
otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_2_1">template<class R, class T> <i>unspecified-2-1</i> mem_fn(R
|
||||
T::*pm)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
|
||||
is equivalent to <tt>t.*pm</tt> when <i>t</i> is of type <STRONG>T</STRONG> <EM>[const]<STRONG>
|
||||
</STRONG></EM>or derived, <tt>get_pointer(t)->*pm</tt> otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_3">template<class R, class T, class A1> <i>unspecified-3</i> mem_fn(R
|
||||
(T::*pmf) (A1))</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
|
||||
is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is an l-value of type <STRONG>T
|
||||
</STRONG>or derived, <tt>(get_pointer(t)->*pmf)(a1)</tt> otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_4">template<class R, class T, class A1> <i>unspecified-4</i> mem_fn(R
|
||||
(T::*pmf) (A1) const)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
|
||||
is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
|
||||
<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)->*pmf)(a1)</tt>
|
||||
otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_5">template<class R, class T, class A1, class A2> <i>unspecified-5</i>
|
||||
mem_fn(R (T::*pmf) (A1, A2))</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
|
||||
is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is an l-value of type <STRONG>
|
||||
T</STRONG> or derived, <tt>(get_pointer(t)->*pmf)(a1, a2)</tt> otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h4><a name="mem_fn_6">template<class R, class T, class A1, class A2> <i>unspecified-6</i>
|
||||
mem_fn(R (T::*pmf) (A1, A2) const)</a></h4>
|
||||
<blockquote>
|
||||
<p>
|
||||
<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
|
||||
is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
|
||||
<EM>[const]</EM> or derived, <tt>(get_pointer(t)->*pmf)(a1, a2)</tt> otherwise.
|
||||
</p>
|
||||
<p>
|
||||
<b>Throws:</b> Nothing.
|
||||
</p>
|
||||
</blockquote>
|
||||
<h2><a name="Implementation">Implementation</a></h2>
|
||||
<h3><a name="Files">Files</a></h3>
|
||||
<ul>
|
||||
<li>
|
||||
<a href="../../boost/mem_fn.hpp">boost/mem_fn.hpp</a>
|
||||
(main header)
|
||||
<li>
|
||||
<a href="../../boost/bind/mem_fn_cc.hpp">boost/bind/mem_fn_cc.hpp</a>
|
||||
(used by mem_fn.hpp, do not include directly)
|
||||
<li>
|
||||
<a href="../../boost/bind/mem_fn_vw.hpp">boost/bind/mem_fn_vw.hpp</a>
|
||||
(used by mem_fn.hpp, do not include directly)
|
||||
<li>
|
||||
<a href="../../boost/bind/mem_fn_template.hpp">boost/bind/mem_fn_template.hpp</a>
|
||||
(used by mem_fn.hpp, do not include directly)
|
||||
<li>
|
||||
<a href="test/mem_fn_test.cpp">libs/bind/test/mem_fn_test.cpp</a>
|
||||
(test)
|
||||
<li>
|
||||
<a href="test/mem_fn_derived_test.cpp">libs/bind/test/mem_fn_derived_test.cpp</a>
|
||||
(test with derived objects)
|
||||
<li>
|
||||
<a href="test/mem_fn_fastcall_test.cpp">libs/bind/test/mem_fn_fastcall_test.cpp</a>
|
||||
(test for __fastcall)
|
||||
<li>
|
||||
<a href="test/mem_fn_stdcall_test.cpp">libs/bind/test/mem_fn_stdcall_test.cpp</a>
|
||||
(test for __stdcall)
|
||||
<li>
|
||||
<a href="test/mem_fn_void_test.cpp">libs/bind/test/mem_fn_void_test.cpp</a> (test
|
||||
for void returns)</li>
|
||||
</ul>
|
||||
<h3><a name="Dependencies">Dependencies</a></h3>
|
||||
<ul>
|
||||
<li>
|
||||
<a href="../config/config.htm">Boost.Config</a></li>
|
||||
</ul>
|
||||
<h3><a name="NumberOfArguments">Number of Arguments</a></h3>
|
||||
<p>
|
||||
This implementation supports member functions with up to eight arguments. This
|
||||
is not an inherent limitation of the design, but an implementation detail.
|
||||
</p>
|
||||
<h3><a name="stdcall">"__stdcall", "__cdecl" and "__fastcall" Support</a></h3>
|
||||
<p>
|
||||
Some platforms allow several types of member functions that differ by their <b>calling
|
||||
convention</b> (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 <b>__stdcall</b>. Borland VCL components use <STRONG>__fastcall</STRONG>.
|
||||
UDK, the component model of OpenOffice.org, uses <STRONG>__cdecl</STRONG>.
|
||||
</p>
|
||||
<p>
|
||||
To use <b>mem_fn</b> with <b>__stdcall</b> member functions, <b>#define</b> the
|
||||
macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including, directly or
|
||||
indirectly, <b><boost/mem_fn.hpp></b>.
|
||||
</p>
|
||||
<P>To use <B>mem_fn</B> with <B>__fastcall</B> member functions, <B>#define</B> the
|
||||
macro <B>BOOST_MEM_FN_ENABLE_FASTCALL</B> before including <B><boost/mem_fn.hpp></B>.
|
||||
</P>
|
||||
<P>To use <B>mem_fn</B> with <B>__cdecl</B> member functions, <B>#define</B> the
|
||||
macro <B>BOOST_MEM_FN_ENABLE_CDECL</B> before including <B><boost/mem_fn.hpp></B>.
|
||||
</P>
|
||||
<P><STRONG>It is best to define these macros in the project options, via -D on the
|
||||
command line, or as the first line in the translation unit (.cpp file) where
|
||||
mem_fn is used.</STRONG> Not following this rule can lead to obscure errors
|
||||
when a header includes mem_fn.hpp before the macro has been defined.</P>
|
||||
<P>[Note: this is a non-portable extension. It is not part of the interface.]
|
||||
</P>
|
||||
<p>
|
||||
[Note: Some compilers provide only minimal support for the <b>__stdcall</b> keyword.]
|
||||
</p>
|
||||
<h2><a name="Acknowledgements">Acknowledgements</a></h2>
|
||||
<p>
|
||||
Rene Jager's initial suggestion of using traits classes to make <b>mem_fn</b> adapt
|
||||
to user-defined smart pointers inspired the <b>get_pointer</b>-based design.
|
||||
</p>
|
||||
<p>
|
||||
Numerous improvements were suggested during the formal review period by Richard
|
||||
Crossley, Jens Maurer, Ed Brey, and others. Review manager was Darin Adler.
|
||||
</p>
|
||||
<p>
|
||||
Steve Anichini pointed out that COM interfaces use <b>__stdcall</b>.
|
||||
</p>
|
||||
<p>
|
||||
Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns on
|
||||
deficient compilers.
|
||||
</p>
|
||||
<p>Daniel Boelzle pointed out that UDK uses <STRONG>__cdecl</STRONG>.<br>
|
||||
<br>
|
||||
<br>
|
||||
<small>Copyright <20> 2001, 2002 by Peter Dimov and Multi Media Ltd. Copyright
|
||||
2003-2005 Peter Dimov. Distributed under the Boost Software License, Version
|
||||
1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or
|
||||
copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
|
||||
</body>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@@ -28,6 +28,9 @@ test-suite "bind"
|
||||
[ run bind_placeholder_test.cpp ]
|
||||
[ run bind_rvalue_test.cpp ]
|
||||
[ run bind_and_or_test.cpp ]
|
||||
[ run bind_void_test.cpp ]
|
||||
[ run bind_void_dm_test.cpp ]
|
||||
[ run bind_void_mf_test.cpp ]
|
||||
[ run mem_fn_test.cpp ]
|
||||
[ run mem_fn_void_test.cpp ]
|
||||
[ run mem_fn_derived_test.cpp ]
|
||||
|
||||
72
test/bind_void_dm_test.cpp
Normal file
72
test/bind_void_dm_test.cpp
Normal file
@@ -0,0 +1,72 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_void_mf_test.cpp - test for bind<void> with member functions
|
||||
//
|
||||
// Copyright (c) 2008 Peter Dimov
|
||||
// Copyright (c) 2014 Agustin Berge
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
//
|
||||
|
||||
struct Z
|
||||
{
|
||||
int m;
|
||||
};
|
||||
|
||||
void member_data_test()
|
||||
{
|
||||
Z z = { 17041 };
|
||||
Z * pz = &z;
|
||||
|
||||
boost::bind<void>( &Z::m, _1 )( z );
|
||||
boost::bind<void>( &Z::m, _1 )( pz );
|
||||
|
||||
boost::bind<void>( &Z::m, z )();
|
||||
boost::bind<void>( &Z::m, pz )();
|
||||
boost::bind<void>( &Z::m, boost::ref(z) )();
|
||||
|
||||
|
||||
Z const cz = z;
|
||||
Z const * pcz = &cz;
|
||||
|
||||
boost::bind<void>( &Z::m, _1 )( cz );
|
||||
boost::bind<void>( &Z::m, _1 )( pcz );
|
||||
|
||||
boost::bind<void>( &Z::m, cz )();
|
||||
boost::bind<void>( &Z::m, pcz )();
|
||||
boost::bind<void>( &Z::m, boost::ref(cz) )();
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
member_data_test();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
171
test/bind_void_mf_test.cpp
Normal file
171
test/bind_void_mf_test.cpp
Normal file
@@ -0,0 +1,171 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_void_mf_test.cpp - test for bind<void> with member functions
|
||||
//
|
||||
// Copyright (c) 2008 Peter Dimov
|
||||
// Copyright (c) 2014 Agustin Berge
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
//
|
||||
|
||||
long global_result;
|
||||
|
||||
//
|
||||
|
||||
struct X
|
||||
{
|
||||
mutable unsigned int hash;
|
||||
|
||||
X(): hash(0) {}
|
||||
|
||||
int f0() { f1(17); return 0; }
|
||||
int g0() const { g1(17); return 0; }
|
||||
|
||||
int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
|
||||
int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
|
||||
|
||||
int f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
|
||||
int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
|
||||
|
||||
int f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
|
||||
int g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }
|
||||
|
||||
int f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
|
||||
int g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }
|
||||
|
||||
int f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
|
||||
int g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }
|
||||
|
||||
int f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
|
||||
int g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }
|
||||
|
||||
int f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
|
||||
int g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }
|
||||
|
||||
int f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
|
||||
int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
|
||||
};
|
||||
|
||||
void member_function_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
X x;
|
||||
|
||||
// 0
|
||||
|
||||
bind<void>(&X::f0, &x)();
|
||||
bind<void>(&X::f0, ref(x))();
|
||||
|
||||
bind<void>(&X::g0, &x)();
|
||||
bind<void>(&X::g0, x)();
|
||||
bind<void>(&X::g0, ref(x))();
|
||||
|
||||
// 1
|
||||
|
||||
bind<void>(&X::f1, &x, 1)();
|
||||
bind<void>(&X::f1, ref(x), 1)();
|
||||
|
||||
bind<void>(&X::g1, &x, 1)();
|
||||
bind<void>(&X::g1, x, 1)();
|
||||
bind<void>(&X::g1, ref(x), 1)();
|
||||
|
||||
// 2
|
||||
|
||||
bind<void>(&X::f2, &x, 1, 2)();
|
||||
bind<void>(&X::f2, ref(x), 1, 2)();
|
||||
|
||||
bind<void>(&X::g2, &x, 1, 2)();
|
||||
bind<void>(&X::g2, x, 1, 2)();
|
||||
bind<void>(&X::g2, ref(x), 1, 2)();
|
||||
|
||||
// 3
|
||||
|
||||
bind<void>(&X::f3, &x, 1, 2, 3)();
|
||||
bind<void>(&X::f3, ref(x), 1, 2, 3)();
|
||||
|
||||
bind<void>(&X::g3, &x, 1, 2, 3)();
|
||||
bind<void>(&X::g3, x, 1, 2, 3)();
|
||||
bind<void>(&X::g3, ref(x), 1, 2, 3)();
|
||||
|
||||
// 4
|
||||
|
||||
bind<void>(&X::f4, &x, 1, 2, 3, 4)();
|
||||
bind<void>(&X::f4, ref(x), 1, 2, 3, 4)();
|
||||
|
||||
bind<void>(&X::g4, &x, 1, 2, 3, 4)();
|
||||
bind<void>(&X::g4, x, 1, 2, 3, 4)();
|
||||
bind<void>(&X::g4, ref(x), 1, 2, 3, 4)();
|
||||
|
||||
// 5
|
||||
|
||||
bind<void>(&X::f5, &x, 1, 2, 3, 4, 5)();
|
||||
bind<void>(&X::f5, ref(x), 1, 2, 3, 4, 5)();
|
||||
|
||||
bind<void>(&X::g5, &x, 1, 2, 3, 4, 5)();
|
||||
bind<void>(&X::g5, x, 1, 2, 3, 4, 5)();
|
||||
bind<void>(&X::g5, ref(x), 1, 2, 3, 4, 5)();
|
||||
|
||||
// 6
|
||||
|
||||
bind<void>(&X::f6, &x, 1, 2, 3, 4, 5, 6)();
|
||||
bind<void>(&X::f6, ref(x), 1, 2, 3, 4, 5, 6)();
|
||||
|
||||
bind<void>(&X::g6, &x, 1, 2, 3, 4, 5, 6)();
|
||||
bind<void>(&X::g6, x, 1, 2, 3, 4, 5, 6)();
|
||||
bind<void>(&X::g6, ref(x), 1, 2, 3, 4, 5, 6)();
|
||||
|
||||
// 7
|
||||
|
||||
bind<void>(&X::f7, &x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind<void>(&X::f7, ref(x), 1, 2, 3, 4, 5, 6, 7)();
|
||||
|
||||
bind<void>(&X::g7, &x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind<void>(&X::g7, x, 1, 2, 3, 4, 5, 6, 7)();
|
||||
bind<void>(&X::g7, ref(x), 1, 2, 3, 4, 5, 6, 7)();
|
||||
|
||||
// 8
|
||||
|
||||
bind<void>(&X::f8, &x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind<void>(&X::f8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
bind<void>(&X::g8, &x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind<void>(&X::g8, x, 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
bind<void>(&X::g8, ref(x), 1, 2, 3, 4, 5, 6, 7, 8)();
|
||||
|
||||
BOOST_TEST( x.hash == 23558 );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
member_function_test();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
139
test/bind_void_test.cpp
Normal file
139
test/bind_void_test.cpp
Normal file
@@ -0,0 +1,139 @@
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(disable: 4786) // identifier truncated in debug info
|
||||
#pragma warning(disable: 4710) // function not inlined
|
||||
#pragma warning(disable: 4711) // function selected for automatic inline expansion
|
||||
#pragma warning(disable: 4514) // unreferenced inline removed
|
||||
#endif
|
||||
|
||||
//
|
||||
// bind_void_test.cpp - test for bind<void>
|
||||
//
|
||||
// Copyright (c) 2008 Peter Dimov
|
||||
// Copyright (c) 2014 Agustin Berge
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(push, 3)
|
||||
#endif
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
|
||||
//
|
||||
|
||||
long global_result;
|
||||
|
||||
long f_0()
|
||||
{
|
||||
return global_result = 17041L;
|
||||
}
|
||||
|
||||
long f_1(long a)
|
||||
{
|
||||
return global_result = a;
|
||||
}
|
||||
|
||||
long f_2(long a, long b)
|
||||
{
|
||||
return global_result = a + 10 * b;
|
||||
}
|
||||
|
||||
long f_3(long a, long b, long c)
|
||||
{
|
||||
return global_result = a + 10 * b + 100 * c;
|
||||
}
|
||||
|
||||
long f_4(long a, long b, long c, long d)
|
||||
{
|
||||
return global_result = a + 10 * b + 100 * c + 1000 * d;
|
||||
}
|
||||
|
||||
long f_5(long a, long b, long c, long d, long e)
|
||||
{
|
||||
return global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e;
|
||||
}
|
||||
|
||||
long f_6(long a, long b, long c, long d, long e, long f)
|
||||
{
|
||||
return global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
|
||||
}
|
||||
|
||||
long f_7(long a, long b, long c, long d, long e, long f, long g)
|
||||
{
|
||||
return global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g;
|
||||
}
|
||||
|
||||
long f_8(long a, long b, long c, long d, long e, long f, long g, long h)
|
||||
{
|
||||
return global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h;
|
||||
}
|
||||
|
||||
long f_9(long a, long b, long c, long d, long e, long f, long g, long h, long i)
|
||||
{
|
||||
return global_result = a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f + 1000000 * g + 10000000 * h + 100000000 * i;
|
||||
}
|
||||
|
||||
void function_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
int const i = 1;
|
||||
|
||||
BOOST_TEST( (bind<void>(f_0)(i), (global_result == 17041L)) );
|
||||
BOOST_TEST( (bind<void>(f_1, _1)(i), (global_result == 1L)) );
|
||||
BOOST_TEST( (bind<void>(f_2, _1, 2)(i), (global_result == 21L)) );
|
||||
BOOST_TEST( (bind<void>(f_3, _1, 2, 3)(i), (global_result == 321L)) );
|
||||
BOOST_TEST( (bind<void>(f_4, _1, 2, 3, 4)(i), (global_result == 4321L)) );
|
||||
BOOST_TEST( (bind<void>(f_5, _1, 2, 3, 4, 5)(i), (global_result == 54321L)) );
|
||||
BOOST_TEST( (bind<void>(f_6, _1, 2, 3, 4, 5, 6)(i), (global_result == 654321L)) );
|
||||
BOOST_TEST( (bind<void>(f_7, _1, 2, 3, 4, 5, 6, 7)(i), (global_result == 7654321L)) );
|
||||
BOOST_TEST( (bind<void>(f_8, _1, 2, 3, 4, 5, 6, 7, 8)(i), (global_result == 87654321L)) );
|
||||
BOOST_TEST( (bind<void>(f_9, _1, 2, 3, 4, 5, 6, 7, 8, 9)(i), (global_result == 987654321L)) );
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
struct Y
|
||||
{
|
||||
short operator()(short & r) const { return global_result = ++r; }
|
||||
int operator()(int a, int b) const { return global_result = a + 10 * b; }
|
||||
long operator() (long a, long b, long c) const { return global_result = a + 10 * b + 100 * c; }
|
||||
void operator() (long a, long b, long c, long d) const { global_result = a + 10 * b + 100 * c + 1000 * d; }
|
||||
};
|
||||
|
||||
void function_object_test()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
short i(6);
|
||||
|
||||
int const k = 3;
|
||||
|
||||
BOOST_TEST( (bind<void>(Y(), ref(i))(), (global_result == 7)) );
|
||||
BOOST_TEST( (bind<void>(Y(), ref(i))(), (global_result == 8)) );
|
||||
BOOST_TEST( (bind<void>(Y(), i, _1)(k), (global_result == 38)) );
|
||||
BOOST_TEST( (bind<void>(Y(), i, _1, 9)(k), (global_result == 938)) );
|
||||
BOOST_TEST( (bind<void>(Y(), i, _1, 9, 4)(k), (global_result == 4938)) );
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
function_test();
|
||||
function_object_test();
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
Reference in New Issue
Block a user