Your question isn’t clear, but I think you might want something like this: int foo(int i){ return i + 1;} typedef int (*g)(int); // Declare typedef g func = &foo; // Define function-pointer variable, and initialise int hvar = func(3); // Call function through pointer
std::function can hold more than function pointers, namely functors. #include <functional> void foo(double){} struct foo_functor{ void operator()(float) const{} }; int main(){ std::function<void(int)> f1(foo), f2((foo_functor())); f1(5); f2(6); } Live example on Ideone. As the example shows, you also don’t need the exact same signature, as long as they are compatible (i.e., the parameter type of std::function … Read more
Definitely. void f(void (*a)()) { a(); } void test() { printf(“hello world\n”); } int main() { f(&test); return 0; }
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
This is not possible. One reason for that is the mechanics of passing parameters differ from function to function, and using an interface{} arg does not mean “accept anything”. For example, a function taking a struct as an arg will receive each member of that struct, but a function taking an interface{} containing that struct … Read more
For both function and object pointers, they compile but their result is only guaranteed to be consistent for addresses to sub-objects of the same complete object (you may compare the addresses of two members of a class or array) and if you compare a function or object against itself. Using std::less<>, std::greater<> and so on … Read more
Maybe. Until C++11, they couldn’t; but C++11 adds: Converting a function pointer to an object pointer type or vice versa is conditionally-supported. The meaning of such a conversion is implementation-defined, except that if an implementation supports conversions in both directions, converting a prvalue of one type to the other type and back, possibly with different … Read more
I don’t believe that there are any facilities provided by the language for doing this. There are overloads for operator << for streams to print out normal void* pointers, but member function pointers are not convertible to void*s. This is all implementation-specific, but typically member function pointers are implemented as a pair of values – … Read more
For a portable solution, you can use boost::asio. Below is a demo I wrote a while ago. You can change t.expires_from_now(boost::posix_time::seconds(1)); to suit you need say make function call after 200 milliseonds. t.expires_from_now(boost::posix_time::milliseconds(200)); Below is a complete working example. It’s calling repeatedly but I think it should be easy to call only once by just … Read more
You cannot cast a function pointer to void*. If you want a function pointer to point to a member function you must declare the type as ReturnType (ClassType::*)(ParameterTypes…) Further you cannot declare a function pointer to a bound member function, e.g. func_ptr p = &t1.get_pc // Error Instead you must get the address like this: … Read more