Converting std::function<void(string, string)> to a generic std::function<void()> - c++

Question

I'm trying somme features of c++0x (under gcc 4.5):
I know it's possible to convert a std::function<void(string, string)> to std::function<void()> when arguments are specified at compilation; but is it possible when arguments are submitted at runtime ?
#include <iostream>
#include <utility>
#include <string>
using namespace std;
using namespace placeholders;
class Print{
public:
void print1(string s1, string s2){ cout<<"s1 : "<<s1<<" s2 : "<<s2<<endl;}
void print2(string s1){ cout<<"s1 : "<<s1<<endl;}
};
Print p = Print();
function<void(string, string)> f1(bind(&Print::print1, &p, _1, _2));
function<void()> f = f1;
I get those errors :
/usr/include/c++/4.5/functional:2103:6: instantiated from ‘std::function<_Res(_ArgTypes ...)>::function(_Functor, typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type) [with _Functor = std::function<void(std::basic_string<char>, std::basic_string<char>)>, _Res = void, _ArgTypes = {}, typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type = std::function<void()>::_Useless]’
../src/Cpp0x_test.cpp:345:34: instantiated from here
/usr/include/c++/4.5/functional:1713:9: error: no match for call to ‘(std::function<void(std::basic_string<char>, std::basic_string<char>)>) ()’
/usr/include/c++/4.5/functional:2111:5: note: candidate is: _Res std::function<_Res(_ArgTypes ...)>::operator()(_ArgTypes ...) const [with _Res = void, _ArgTypes = {std::basic_string<char>, std::basic_string<char>}]
Actually I need to do :
function<void(string, string)> f1(bind(&Print::print1, &p, _1, _2));
function<void(string)> f2(bind(&Print::print2, &p, _1));
function<void()> fx1 = f1;
function<void()> fx2 = f2;
std::vector<function<void()> > vec;
vec.push_back(fx1);
vec.push_back(fx2);
//then, later
function<void()> call1 = vec[0];
function<void()> call2 = vec[1];
call1("test1", "test2");
call2("test3");

Answer 1

The question doesn't really make sense.
I know it's possible to convert a std::function<void(string, string)>
to std::function<void()> when arguments are specified at compilation;
but is it possible when arguments are submitted at runtime ?
If you're talking about doing this to set the arguments "at compilation":
string arg1,arg2;
function<void()> f = bind(f1,arg1,arg2); // f = [=] { f1(arg1,arg2); };
this is actually doing the binding at runtime. Whatever value those arguments have when bind is called, even if they are set at runtime, say, from user input, the calling f() will use those runtime values.
Perhaps you mean that the above code binds f1 to the value of arg1 and arg2 at the time bind is called, and that changing the values of the objects used in bind later on doesn't affect the values used in calls to f(). There's a way around that:
string arg1,arg2;
function<void()> f =
bind(f1,std::ref(arg1),std::ref(arg2)); // f = [&,f1] { f1(arg1,arg2); };
This causes f to hold references to the objects instead of just the static value used at the time bind is called. You can now assign new values to arg1 and arg2 and when f() is called the new values will be used. Note that you have to make sure that the references held by f remain valid and don't become dangling references so long as f can still be called.
function<void(string)> foo = [](string s){ cout << s; };
string arg = "Hello,";
function<void()> bar = bind(foo,ref(arg)); // bar = [=,&arg] { foo(arg); };
bar(); // prints "Hello,"
arg = " World!"
bar(); // prints " World!"

Answer 2

Its possible using bind aswell:
string arg1, arg2;
function<void()> f(bind(f1, arg1, arg2));
f(); // calls f1(arg1, arg2) with their values at the time of bind

Answer 3

Let's see if I understand your requirement.
Why don't you just store the arguments in a vector instead of the functions?
std::vector<std::tuple<std::string,std::string>> v;
v.push_back(std::make_tuple("a", "b")); // repeat
// Later that day...
for(auto& t : v) {
f(get<0>(t), get<1>(t));
}