Replace argument on nested boost :: bind without composition

Question

Suppose I have a function that takes a null functor as an argument:

void enqueue( boost::function<void()> & functor );

I have another function that takes an int and does something internally:

void foo( int a);

I would like to nest, but not compose, together to get a functor with a signature:

boost::function<void(int)> functor

That when called with a value - say 4 - does the following:

enqueue( boost::bind(&foo, 4) )

My first attempt was as follows:

boost::function<void(int)> functor = boost::bind(&enqueue, boost::bind(&foo,_1))

This fails because bind executes the composition when nested binding is specified. foo was first called, then the void value was "returned" to the queue, which fails.

My second attempt was as follows:

boost::function<void(int)> functor = boost::bind(&enqueue, boost::protect( boost::bind(&foo, _1) ) )

This failed because enqueue accepts a null, not a unary functor.

Can I do what I'm looking for?

Additional Information:

• 6 : http://lists.boost.org/boost-users/2004/07/7125.php
• , boost:: lambda:: bind boost:: lambda:: unlambda boost:: lambda:: protect , . , boost:: lambda (3) .

Answer 1

...

, , " ". , foo(x, y) bind(&foo, x, y), bind(&foo, x) bind(&bind, &foo, x). , , , boost::bind , , :

// One single line, broken for "readability"
boost::function<void(int)> f = boost::bind(
  &enqueue, 
  boost::bind(
    static_cast<
      boost::_bi::bind_t<
        void, void(*)(int), boost::_bi::list_av_1<int>::type
      >
      (*)(void(*)(int), int)
    >(&boost::bind), 
    &foo, 
    _1
  )
);

, , , , "", . :

boost::_bi::bind_t<void, void(*)(int), boost::_bi::list_av_1<int>::type>
  (*bind_foo)(void(*)(int), int) = &boost::bind;

boost::function<void(int)> q = boost::bind(&enqueue, boost::bind(bind_foo, &foo, _1));

;)

Edit:

OP , / ++ 0x : :

auto f = [](int i){enqueue([=](){foo(i);});};

Answer 2

"" :

class Enqueuer {
 std::function<void (int)> mFunc;

public:
 void operator()(int pVal) {
  enqueue(std::bind(mFunc, pVal));
 }

 Enqueuer(std::function<void (int)> pFunc)
  : mFunc(pFunc) {}
};

// usage:
Enqueuer e(foo);
e(1);
e(2);
e(3);