C++ C++；11个样式回调？

我在一个类中有一个空函数。在旧C++中，我将把函数名静态化为类名，并拥有自己的类，它采用静态空格函数+空格*，方便调用。

---

然而，这感觉很老派。它也不是模板，感觉我可以做得更多。创建myclassVar回调的更现代的方法是什么。voidReturnVoidParamFunc用于存储可调用项：

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

#包括
#包括
课堂测试
{
公众：
空隙BRAH（）{STD::CUT< P>，用LAMBDA和向量传递参数到C++ 11回调的例子，见或低于：

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

    }
}      

类测试
{
公众：
Test（int testType）：m_testType（testType）{}；
void blah（）{std:：cout@Hauleth我没有说它很复杂，我说的是用lambda更清楚。记住参数顺序（特别是当你得到模糊的编译错误时，如果顺序错误）会使它“更难”我知道你很久以前就发布过这个，但我需要澄清一下：在main的前3行中，你将类实例作为参数绑定到类函数本身，因为当我们通常调用类成员函数时，编译器也会秘密地这样做，对吗o编译器将实例的引用作为第一个参数添加到每个函数的此参数！您能确认我的假设吗？代码中的绑定有问题，它应该采用类似
std:：functioncallback=std:：bind（&Test:：blah，&Test）的指针；
@dynamode都是有效的，但在示例中，
回调
对象中有一个
测试
的副本，而在您的版本中，它将是一个指针，放在
回调
中。正如预期的那样，只要指针和/或对象在调用时有效，这两个都可以工作。@binaryguy这不是编译器猜测stuffs，它是
std:：bind
implementation/definition（这就是为什么当传递错误时，复杂的代码会产生奇怪的错误的部分原因）。简而言之，它检测到您正在提供一个成员函数，在这种情况下，它希望第二个参数是指向相关类型的对象的指针或
std:：reference_wrapper
或要复制的对象。这里有一个bind获取的
test
对象的副本。如果要传递引用，必须使用<代码> STD:：Ref>代码>或代码> STD:：CREF。你也可以通过一个指针，比如@ DeaDoMoDoT。“它也不是模板，它感觉我可以做更多。”C++代码不必被模板化为C++。