c++ - C++11 风格的回调？

Question

我在一个类中有一个 void 函数。在旧的 C++ 中，我会制作一个静态函数，将类名作为参数，并拥有我自己的类，该类采用静态 void 函数 + void*，以便我轻松调用它。

然而，这感觉老派。它也不是模板化的，感觉我可以做更多。创建对 myclassVar.voidReturnVoidParamFunc 的回调的更现代的方法是什么

Answer 1

使用std::function和 lambdas (or std::bind())来存储可调用对象：

#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();
}      

结果：

废话！

建筑信息模型！

砰！

废话！

编译运行：http: //ideone.com/T6wVp

std::function可以用作任何可复制的对象，因此可以随意将其作为回调存储在某个地方，例如在对象的成员中。这也意味着您可以自由地将其放入标准容器中，例如std::vector< std::function< void () > >.

另请注意，等效的boost::function 和 boost::bind已经存在多年了。

Answer 2

有关使用 Lambda 和向量将参数传递给 C++ 11 回调的示例，请参阅http://ideone.com/tcBCeO或以下内容：

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);

    }
}