Why std::bind can't be param of parameters pack? - c++

Question

I'd like to use parameters pack, but find the problem.
Some code:
template <typename Function, typename... Args>
auto f(Function func, Args... args) -> decltype(func(args...))
{
auto f11 = std::bind(func, args...);
f11();
}
void print(const char* string)
{
std::cout << string << std::endl;
}
All of this works well:
f([] (const char* additional, const char* more) {
std::cout << "hello ( " << additional << ", " << more << " )" << std::endl;
}, "additional text", "and one more");
auto printFunction = std::bind(&print, std::placeholders::_1);
printFunction("hello from print bind");
f(print, "hello from print directly");
but if i would like to give std::function to parameters pack:
f([] (std::function<void(const char*)> printParamFunc) {
printParamFunc("hello from print from std::function");
}, printFunction);
application no more compiles.
So, what the problem to use function as parameter in pack?
Thanks.
UPDATE:
if change code of f to:
template <typename Function, typename... Args>
auto f(Function func, Args... args) -> decltype(func(args...))
{
func(args...);
}
it works well, but i wouldn't like to execute this function here, i wanna create function and pass it like param.
UPDATE2:
Code execution example: http://ideone.com/gDjnPq
UPDATE3:
Clear code with compilation error: http://ideone.com/50z7IN

Answer 1

I understand the situation a bit better now.
Problem can be retroduced by this code:
void print(const char* string)
{
std::cout << string << std::endl;
}
int main(int argc, char ** argv)
{
auto lambda = [] (std::function< void ( const char * ) > printParamFunc) {
printParamFunc("hello from lambda!");
};
std::bind(lambda, std::bind(print, std::placeholders::_1))();
}
Nested std::bind trying to evaluate and fails with conversion _1 to const char *. It is specific of std::bind.
We need analogue of boost::bind::protect -- functor storing other functor -- and it is solve problem:
template <class F>
struct lazy_evaluate {
typedef typename F::result_type T;
explicit lazy_evaluate(F f) : f_(f) {}
template <class... Args>
T operator()(Args&&... args)
{
f_(std::forward<Args>(args)...);
}
private:
F f_;
};
template <class F>
lazy_evaluate<F> lazy(F f)
{
return lazy_evaluate<F>(f);
}
nested std::bind now looks like:
std::bind(lambda, lazy(std::bind(print, std::placeholders::_1)))();
and works well.