The short answer is “templates are not string substitution”. void f(void) has meaning only so far as it is an alias for void f() in C++, in order to be backwards compatible with C. The first step is to use variadics, as noted elsewhere. The second step is figuring out how to map void returning … Read more
std::function is a type erasure object. That means it erases the details of how some operations happen, and provides a uniform run time interface to them. For std::function, the primary1 operations are copy/move, destruction, and ‘invocation’ with operator() — the ‘function like call operator’. In less abstruse English, it means that std::function can contain almost … Read more
Your code has undefined behavior. It may or may not work as you expect. The reason it has undefined behavior is because of 20.8.11.2.1 [func.wrap.func.con]/p7: Requires: F shall be CopyConstructible. f shall be Callable (20.8.11.2) for argument types ArgTypes and return type R. For f to be Callable for return type R, f must return … Read more
std::bind is for partial function application. That is, suppose you have a function object f which takes 3 arguments: f(a,b,c); You want a new function object which only takes two arguments, defined as: g(a,b) := f(a, 4, b); g is a “partial application” of the function f: the middle argument has already been specified, and … Read more
You can easily wrap member functions using the following code (which is a well known solution) class gsl_function_pp : public gsl_function { public: gsl_function_pp(std::function<double(double)> const& func) : _func(func){ function=&gsl_function_pp::invoke; params=this; } private: std::function<double(double)> _func; static double invoke(double x, void *params) { return static_cast<gsl_function_pp*>(params)->_func(x); } }; Then you can use std::bind to wrap the member function … Read more
It’s obvious to us which function you intend to be chosen, but the compiler has to follow the rules of C++ not use clever leaps of logic (or even not so clever ones, as in simple cases like this!) The relevant constructor of std::function is: template<class F> function(F f); which is a template that accepts … Read more
operator== for std::function compares a std::function with a null pointer, as far as I can tell the standard does not provide any details as to why. Although, this boost FAQ entry, Why can’t I compare boost::function objects with operator== or operator!=? provides a rationale and as far as I can tell should be applicable to … Read more
Can I store the function as a reference since std::function is just a function-pointer and the ‘executable code’ of the function is guaranteed to stay in memory? std::function is very much not just a function pointer. It’s a wrapper around an arbitrary callable object, and manages the memory used to store that object. As with … Read more
I think according to the C++11 standard, this should be supported Not really, because a non-static member function has an implicit first parameter of type (cv-qualified) YourType*, so in this case it does not match void(int). Hence the need for std::bind: Register(std::bind(&Class::Function, PointerToSomeInstanceOfClass, _1)); For example Class c; using namespace std::placeholders; // for _1, _2 … Read more
You haven’t said what you expect to be able to do with func2 after putting it in a vector with the wrong type. You can easily use std::bind to put it in the vector if you know the arguments ahead of time: const std::vector<std::function<void(std::string)>> functions { func1, std::bind(func2, std::placeholders::_1, 5, 6) }; Now functions[1](“foo”) will … Read more