What is the best way to pass callback function to std::map?

Question

I was trying to work on the below code but the program crashes:

#include <iostream>
#include <string>
#include <map>

using namespace std;

typedef void (*callBackMethod)(string);
class CTest
{
private:
    map<string, callBackMethod> mapMethod;

    void testMethod(string msg)
    {
        cout << msg << endl;
    }
public:
    CTest()
    {
        addFunction("AA", (callBackMethod) &CTest::testMethod);
    }
    void addFunction(string funName, callBackMethod methodName)
    {
        mapMethod[funName] = methodName;
    }
    callBackMethod getMethod(string funName)
    {
        auto fun = mapMethod.find(funName);
        if(fun == mapMethod.end()) { return nullptr; }
        return fun->second;
    }
    void runFunction(string funName)
    {
        getMethod(funName)("test");
    }

};

int main()
{
    CTest test;
    test.runFunction("AA");

    return 0;
}

I have a requirement where I need to pass private methods to a map. The program compiles with warning:

converting from 'void (CTest::*)(std::__cxx11::string) {aka void (CTest::*)(std::__cxx11::basic_string<char>)}' to 'callBackMethod {aka void (*)(std::__cxx11::basic_string<char>)}'

and when I execute this, it crashes.

When I move the callback method outside of the class it works. My requirement is to make the program flow this was (hide the methods from external call which needs to be added to a map).

Looking forward to your comments.

Why on earth do you think casting a pointer-to-member-function to a pointer-to-function is a good idea?! — T.C., Dec 21 '15 at 10:15
@T.C. Then what do you suggest? Please modify the code if you want to,. — programmer, Dec 21 '15 at 10:17
Possible duplicate of [how to pass a non static-member function as a callback?](http://stackoverflow.com/questions/2097738/how-to-pass-a-non-static-member-function-as-a-callback) — n. m. could be an AI, Dec 21 '15 at 13:25
[Mandatory reading](https://isocpp.org/wiki/faq/pointers-to-members) — n. m. could be an AI, Dec 21 '15 at 13:27

CJCombrink · Answer 1 · 2015-12-21T14:25:09.270

0

Since you want to use member variables you need to specify the signature differently in your typedef:

In C++ Builder the following can be done:

typedef void(__closure *callBackMethod)(string);

If you do that, I do suggest that you keep a smart pointer to the object that the member belongs to so that you can check if the object is still valid before calling the function otherwise it will crash the application.

The __closure keyword is a C++ Builder extension to work around the requirement to use fully qualified member names source

To handle both global and member functions we have the following:

typedef void(__closure *callBackMethodMember)(string);
typedef void (*callBackMethodGlobal)(string);

/* And then on 2 overloaded functions */
void addFunction(string funName, callBackMethodMember methodName) {}
void addFunction(string funName, callBackMethodGlobal methodName) {}

edited Dec 21 '15 at 14:25

answered Dec 21 '15 at 12:35

CJCombrink

3,738
1
22
38

What does `__closure` mean? Is it standard C++? – Antonio Pérez Dec 21 '15 at 13:01
I see that `__closure` is a C++ Builder extension to c++. So if you are not using C++ Builder it will not be available. [Docs](http://docwiki.embarcadero.com/RADStudio/XE8/en/C%2B%2B_Keyword_Extensions#closure) – CJCombrink Dec 21 '15 at 13:09
But what does it do? There might be a standard equivalence. – Antonio Pérez Dec 21 '15 at 13:09
look at the link I provided, there is a nice example of what it tries to achieve. Perhaps look into std::function and std::bind – CJCombrink Dec 21 '15 at 13:12

Antonio Pérez · Accepted Answer · 2015-12-21T14:23:56.403

0

If you need to point to both CTest member functions and free functions, then you can use std::function<void(std::string)>.

#include <iostream>
#include <string>
#include <map>
#include <functional>

using namespace std;

using callBackFunction = std::function<void(string)>;

void testFunction(string msg)
{
    cout << "[" << __PRETTY_FUNCTION__ << "] " << msg << endl;
}

class CTest
{
private:
    map<string, callBackFunction> mapMethod;

    void testMethod(string msg)
    {
        cout << "[" << __PRETTY_FUNCTION__ << "] " << msg << endl;
    }
public:
    CTest()
    {
        addFreeFunction("AA", testFunction);
        addMemberFunction("BB", &CTest::testMethod);
    }
    void addMemberFunction(string funName, void(CTest::*methodName)(string))
    {
        using std::placeholders::_1;
        mapMethod[funName] = std::bind(methodName, this, _1);
    }
    void addFreeFunction(string funName, void(*methodName)(string))
    {
        mapMethod[funName] = methodName;
    }
    callBackFunction getMethod(string funName)
    {
        auto fun = mapMethod.find(funName);
        if(fun == mapMethod.end()) { return nullptr; }
        return fun->second;
    }
    void runFunction(string funName)
    {
        getMethod(funName)("test");
    }

};

int main()
{
    CTest test;
    test.runFunction("AA");
    test.runFunction("BB");

    return 0;
}

Notice that CTest must insert elements into the map in a different way depending on what type of function you are passing, since for member functions you must provide the object for which it is to be invoked, this in this example. This is achived by using std::bind.

edited Dec 21 '15 at 14:23

answered Dec 21 '15 at 12:50

Antonio Pérez

6,702
4
36
61

thanks. Your code worked. But now the callback method signature is hidden. I need to also pass callback methods from main. For ex: void tst2(string s) {cout << "New " << s;} .... and inside main(){ .... test.addFunction("BB", &tst2); ...} fails with compile error. Is there a better way to handle both this case. Thanks a lot. – programmer Dec 21 '15 at 13:06
So you need to use both member and non-member functions? – Antonio Pérez Dec 21 '15 at 13:08
yes. I need to use both member and non-member functions. – programmer Dec 21 '15 at 13:09
What we do in this case is to have everything overloaded for both member and non member. This is in really old code and might not be the best way but at the time it worked well. We moved over to [Qt](http://www.qt.io/) and use the signals and slots now instead. – CJCombrink Dec 21 '15 at 13:15
@The Badger, do you have an example to share? – programmer Dec 21 '15 at 13:28
@programmer I have updated my answer to show how we do it, but rather look at this answer for a better solution. I am also struggling with this exact issue for new code: http://stackoverflow.com/questions/34397819/using-stdfunction-and-stdbind-to-store-callback-and-handle-object-deletion – CJCombrink Dec 21 '15 at 14:27
@programmer Look at the answer to my question link above for a C++11 based approach. I had the code and question typed up a while back but your question made me revisit the problem and post the question. – CJCombrink Dec 22 '15 at 06:05

What is the best way to pass callback function to std::map?

2 Answers2