boost-bind

I noticed that when passing reference parameters to boost bind, those parameters won't act like references. Instead boost creates another copy of the member and the original passed in variable remains unchanged. When I change the references to pointers, everything works ok. My question is: Is it possible to get references to work, or at least give a compiling error when it tries to use reference parameters? Timo Geusch The boost documentation for bind suggests that you can use boost::ref and boost::cref for this. I ran into similar issue expecting a bind parameter to be passed by reference

could someone summarize in a few succinct words how the boost shared_from_this<>() smart pointer should be used, particularly from the perspective of registering handlers in the io_service using the bind function. EDIT: Some of the responses have asked for more context. Basically, I'm looking for "gotchas", counter-intuitive behaviour people have observed using this mechanism. The biggest "gotcha" I've run into is that it's illegal to call shared_from_this from the constructor. This follows directly from the rule that a shared_ptr to the object must exist before you can call shared_from_this.

Please have a look at this example posted by Johannes Schaub to sort a vector of pairs: How do I sort a vector of pairs based on the second element of the pair? std::sort(a.begin(), a.end(), boost::bind(&std::pair<int, int>::second, _1) < boost::bind(&std::pair<int, int>::second, _2)); I thought I do understand boost::bind, but I have trouble with this one. Question 1: the sort algorithm is expecting a predicate function as a third parameter. What I see here, is a boolean expression. What am I missing?: boost::bind(&std::pair<int, int>::second, _1) < boost::bind(&std::pair<int, int>::second,

I have some pretty basic test code. I have a class that just logs all operations on it. I bound it to a boost::function object like this: void Function(const Foo&) { printf("Function invoked\n"); } // ... boost::function<void(void)> func; { Foo f; printf("\nConstructing function\n"); func = boost::bind(&Function, f); printf("Construction complete\n\n"); } I expect that the function object contains a copy of f . So creating at least one copy is mandatory. However, I find that I get 13 temporaries. Output is: Constructing function Foo::Foo(const Foo&) Foo::Foo(const Foo&) Foo::Foo(const Foo&)

Suppose I have a function which takes a nullary functor as an argument: void enqueue( boost::function<void()> & functor ); I have another function which takes an int and does something internally: void foo( int a); I would like to nest, but not compose, these together so that I get a functor with the signature: boost::function<void(int)> functor Which when called with a value - say 4 - performs the following: enqueue( boost::bind(&foo, 4) ) My first attempt was the following: boost::function<void(int)> functor = boost::bind(&enqueue, boost::bind(&foo,_1)) This fails because bind performs

I've always believed that function pointers don't require an ampersand: Do function pointers need an ampersand Yet, every example I've seen of using boost::bind shows one, and my compiler - in most situations - gives a typically inscrutable error message if it's omitted. synchronize(boost::bind(&Device::asyncUpdate , this, "ErrorMessage")); // Works synchronize(boost::bind(Device::asyncUpdate , this, "ErrorMessage")); // Fails Am I wrong in assuming that boost::bind 's first parameter is basically function pointer? Function pointers don't need it, member function pointers do. Device: