#include <functional>
#include <iostream>
#include <vector>


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