compiler - C++ 11 llamadas de devolución de estilo?

c++17

Question

Tengo una función de vacío dentro de una clase. En el antiguo C ++ hacía una función estática tomando el nombre de la clase como un parámetro y tenía mi propia clase que tomaba una función de vacío estático + un vacío * para que la llamara fácilmente.

Sin embargo eso se siente la vieja escuela. Tampoco tiene la plantilla que se siente como si pudiera estar haciendo más. ¿Cuál es una forma más moderna de crear devoluciones de llamada a myclassVar.voidReturnVoidParamFunc

Answer 1

Para ver un ejemplo de pasar parámetros a una devolución de llamada de C ++ 11 utilizando Lambda y un vector, consulte http://ideone.com/tcBCeO o más abajo:

class Test
{
public:
      Test (int testType) : m_testType(testType) {};
      void blah() { std::cout << "BLAH! " << m_testType << std::endl; }
      void blahWithParmeter(std::string p) { std::cout << "BLAH1! Parameter=" << p << std::endl; }
      void blahWithParmeter2(std::string p) { std::cout << "BLAH2! Parameter=" << p << std::endl; }

      private:
         int m_testType;

};

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(7);  
    //std::function< void() > callback = std::bind( &Test::blah, 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(); }; // might be clearer than calling std::bind()
    callback();

    // example of callback with parameter using a vector
    typedef std::function<void(std::string&)> TstringCallback;

    std::vector <TstringCallback> callbackListStringParms;
    callbackListStringParms.push_back( [&] (const std::string& tag) {     test.blahWithParmeter(tag); }); 
    callbackListStringParms.push_back( [&] (const std::string& tag) { test.blahWithParmeter2(tag); }); 

    std::string parm1 = "parm1";
    std::string parm2 = "parm2";
    int i = 0;
    for (auto cb : callbackListStringParms ) 
    {
        ++i;
        if (i == 1)
            cb(parm1);
        else
            cb(parm2);

    }
}      

Answer 2

Use std::function y lambdas (o std::bind() ) para almacenar 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();
}      

Resultado:

¡PAJA!

BIM!

BOUM!

¡PAJA!

Compila y ejecuta: http://ideone.com/T6wVp

std::function se puede usar como cualquier objeto copiable, así que siéntase libre de almacenarlo en algún lugar como devolución de llamada, como en el miembro del objeto. También significa que puedes ponerlo libremente en contenedores estándar, como std::vector< std::function< void () > > .

También tenga en cuenta que el refuerzo equivalente :: function y boost :: bind han estado disponibles durante años.