Note: Most of the answers cover function pointers which is one possibility to achieve “callback” logic in C++, but as of today not the most favourable one I think. What are callbacks(?) and why to use them(!) A callback is a callable (see further down) accepted by a class or function, used to customize the … Read more
You have a good example here (Array of Function pointers), with the syntax detailed. int sum(int a, int b); int subtract(int a, int b); int mul(int a, int b); int div(int a, int b); int (*p[4]) (int x, int y); int main(void) { int result; int i, j, op; p[0] = sum; /* address of … Read more
Anonymous inner class Say you want to have a function passed in with a String param that returns an int. First you have to define an interface with the function as its only member, if you can’t reuse an existing one. interface StringFunction { int func(String param); } A method that takes the pointer would … Read more
I just ran into this problem. The code compiles fine without lambda captures, but there is a type conversion error with lambda capture. Solution with C++11 is to use std::function (edit: another solution that doesn’t require modifying the function signature is shown after this example). You can also use boost::function (which actually runs significantly faster). … Read more
Consider the signal() function from the C standard: extern void (*signal(int, void(*)(int)))(int); Perfectly obscurely obvious – it’s a function that takes two arguments, an integer and a pointer to a function that takes an integer as an argument and returns nothing, and it (signal()) returns a pointer to a function that takes an integer as … Read more
There isn’t anything wrong with using function pointers. However, pointers to non-static member functions are not like normal function pointers: member functions need to be called on an object which is passed as an implicit argument to the function. The signature of your member function above is, thus void (aClass::*)(int, int) rather than the type … Read more
As far as the C standard is concerned, if you cast a function pointer to a function pointer of a different type and then call that, it is undefined behavior. See Annex J.2 (informative): The behavior is undefined in the following circumstances: A pointer is used to call a function whose type is not compatible … Read more
It’s not quite the right question. For C, at least, the right question is What happens to a function value in an rvalue context? (An rvalue context is anywhere a name or other reference appears where it should be used as a value, rather than a location — basically anywhere except on the left-hand side … Read more
This is a simple question but the answer is surprisingly complex. The short answer is you can do what you’re trying to do with std::bind1st or boost::bind. The longer answer is below. The compiler is correct to suggest you use &CLoggersInfra::RedundencyManagerCallBack. First, if RedundencyManagerCallBack is a member function, the function itself doesn’t belong to any … Read more
A non-static member function must be called with an object. That is, it always implicitly passes “this” pointer as its argument. Because your std::function signature specifies that your function doesn’t take any arguments (<void(void)>), you must bind the first (and the only) argument. std::function<void(void)> f = std::bind(&Foo::doSomething, this); If you want to bind a function … Read more