- |
- |
-
- bind.hpp- |
-
| - | |
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. -
-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::ref and 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(42), _1); --
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 noncopyable, 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 );
-
- 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::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>(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 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::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(). -
-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 for an example that demonstrates how to use bind - to achieve similar functionality to 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 boost/bind/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 boost/bind/protect.hpp contains an implementation of - protect. To protect a bind function object from - evaluation, use protect(bind(f, ...)).
-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
-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)));
-}
-
- class button
-{
-public:
-
- 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);
-}
-
- 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 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. -
-See the dedicated Troubleshooting section.
-Probably because you used the general bind<R>(f, ...) syntax, - thereby instructing bind to not "inspect" f to detect arity and - return type errors.
-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.
-Yes, if you #define BOOST_BIND_ENABLE_STDCALL. An - alternative is to treat the function as a generic - function object and use the bind<R>(f, ...) syntax.
-Yes, if you #define BOOST_MEM_FN_ENABLE_STDCALL.
-Yes, if you #define BOOST_BIND_ENABLE_PASCAL. An - alternative is to treat the function as a generic - function object and use the bind<R>(f, ...) syntax.
-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 generic - function object and use the bind<R>(f, ...) syntax.
-Non-portable extensions, in general, should default to off to prevent vendor - lock-in. Had the 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.
-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
-}
-
- 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
-}
-
- 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).
-The bind(f, a1, a2, ..., aN) 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.
-The bind<R>(f, a1, a2, ..., aN) 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.
-By default, the bind(f, a1, a2, ..., aN) form recognizes - "ordinary" C++ functions and function pointers. 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) 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 "__stdcall" and "pascal" Support.
-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 );
-}
-
- The function objects that are produced by boost::bind do not model the - STL Unary Function or - 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 boost::bind to be combined with - STL templates such as std::unary_negate - and std::binary_negate.
- -The make_adaptable function is defined in <boost/bind/make_adaptable.hpp>, - which must be included explicitly in addition to <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, boost::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 - std::not1.
- -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. -
-On MSVC (up to version 7.0), when boost::bind 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; --
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.
-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); --
namespace boost
-{
-
-// no arguments
-
-template<class R, class F> unspecified-1 bind(F f);
-
-template<class F> unspecified-1-1 bind(F f);
-
-template<class R> unspecified-2 bind(R (*f) ());
-
-// one argument
-
-template<class R, class F, class A1> unspecified-3 bind(F f, A1 a1);
-
-template<class F, class A1> unspecified-3-1 bind(F f, A1 a1);
-
-template<class R, class B1, class A1> unspecified-4 bind(R (*f) (B1), A1 a1);
-
-template<class R, class T, class A1> unspecified-5 bind(R (T::*f) (), A1 a1);
-
-template<class R, class T, class A1> unspecified-6 bind(R (T::*f) () const, A1 a1);
-
-template<class R, class T, class A1> unspecified-6-1 bind(R T::*f, A1 a1);
-
-// two arguments
-
-template<class R, class F, class A1, class A2> unspecified-7 bind(F f, A1 a1, A2 a2);
-
-template<class F, class A1, class A2> unspecified-7-1 bind(F f, A1 a1, A2 a2);
-
-template<class R, class B1, class B2, class A1, class A2> unspecified-8 bind(R (*f) (B1, B2), A1 a1, A2 a2);
-
-template<class R, class T, class B1, class A1, class A2> unspecified-9 bind(R (T::*f) (B1), A1 a1, A2 a2);
-
-template<class R, class T, class B1, class A1, class A2> unspecified-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
-
-}
-
- 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.
-The function µ(x, v1, v2, ..., vm), where m is - a nonnegative integer, is defined as:
---Returns: A function object λ such that the expression λ(v1, - v2, ..., vm) is equivalent to f(), - implicitly converted to R.
-Throws: Nothing unless the copy constructor of F throws an - exception.
-
--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.
-
--Returns: A function object λ such that the expression λ(v1, - v2, ..., vm) is equivalent to f().
-Throws: Nothing.
-
--Returns: A function object λ such that the expression λ(v1, - v2, ..., vm) is equivalent to f(µ(a1, - v1, v2, ..., vm)), implicitly - converted to R.
-Throws: Nothing unless the copy constructors of F or A1 throw - an exception.
-
--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.
-
--Returns: A function object λ such that the expression λ(v1, - v2, ..., vm) is equivalent to f(µ(a1, - v1, v2, ..., vm)).
-Throws: Nothing unless the copy constructor of A1 throws an - exception.
-
--Effects: Equivalent to bind<R>(boost::mem_fn(f), - a1);
-
--Effects: Equivalent to bind<R>(boost::mem_fn(f), - a1);
-
--Effects: Equivalent to bind<R>(boost::mem_fn(f), - a1);
-
--Returns: A function object λ such that the expression λ(v1, - v2, ..., vm) is equivalent to f(µ(a1, - v1, v2, ..., vm), µ(a2, v1, - v2, ..., vm)), implicitly converted to R.
-Throws: Nothing unless the copy constructors of F, A1 or A2 - throw an exception.
-
--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.
-
--Returns: A function object λ such that the expression λ(v1, - v2, ..., vm) is equivalent to f(µ(a1, - v1, v2, ..., vm), µ(a2, v1, - v2, ..., vm)).
-Throws: Nothing unless the copy constructors of A1 or A2 throw - an exception.
-
--Effects: Equivalent to bind<R>(boost::mem_fn(f), - a1, a2);
-
--Effects: Equivalent to bind<R>(boost::mem_fn(f), - a1, a2);
-
Implementations are allowed to provide additional bind overloads in order - to support more arguments or different function pointer variations.
-This implementation supports function objects with up to nine arguments. This is - an implementation detail, not an inherent limitation of the design.
-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.]
-Function objects returned by bind support the experimental and - undocumented, as of yet, visit_each enumeration interface.
-See bind_visitor.cpp for an example.
-Earlier efforts that have influenced the library design:
-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 - 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ärvi. -
-Dave Abrahams fixed a MSVC-specific conflict between bind and the - 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.
-
-
-
- Copyright © 2001, 2002 by Peter Dimov and Multi Media Ltd. Copyright
- 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.
+ Automatic redirection failed, please go to + doc/html/bind.html +
+
+ © 2001, 2002 Peter Dimov and Multi Media Ltd.
+ © 2003-2008 Peter Dimov
+