Question

I have a void function inside of a class. In old C++ i’d make a function static taking the class name as a parameter and had my own class which took a static void function + a void* for me to easily call it.

However that feels old school. It also isn’t templated which feels like i could be doing more. What is a more modern way of creating callbacks to myclassVar.voidReturnVoidParamFunc

Answer 1

Use std::function and lambdas (or std::bind()) to store callables:

#include <functional>
#include <iostream>


class Test
{
public:
      void blah() { std::cout << "BLAH!" << std::endl; }
};

class Bim
{
public:
      void operator()(){ std::cout << "BIM!" << std::endl; }
};

void boum() { std::cout << "BOUM!" << std::endl; }


int main()
{
    // store the member function of an object:
    Test test;  
    std::function< void() > callback = std::bind( &Test::blah, test );
    callback();

    // store a callable object (by copy)
    callback = Bim{};
    callback();

    // store the address of a static function
    callback = &boum;
    callback();

    // store a copy of a lambda (that is a callable object)
    callback = [&]{ test.blah(); }; // often clearer -and not more expensive- than std::bind()
    callback();
}      

Result:

BLAH!

BIM!

BOUM!

BLAH!

Compiles and run: http://ideone.com/T6wVp

std::function can be used as any copyiable object, so feel free to store it somewhere as a callback, like in object’s member. It also means that you can freely put it in standard containers, like std::vector< std::function< void () > > .

Also note that equivalent boost::function and boost::bind have been available for years.