C++ map of member function pointers of different classes

Question

I am trying to create a map that contains member function pointers of different classes. The member functions all have the same signature. In order to do this all my classes inherit an Object class which only has default constructor, virtual destructor and a virtual ToString() const method.

// The map looks like this
map<Object*, void (Object::*)()> mapOfMethodPointers;

// And here are the two classes that inherit Object
// Class A
class A : public Object
{
public:
    void AFunc();

    string ToString() const override;
};

void A::AFunc()
{
    cout << "AFunc()" << endl;
}

string A::ToString() const
{
    cout << "A" << endl;
}

// Class B
class B : public Object
{
public:
    void BFunc();

    string ToString() const override;
}

void B::BFunc()
{
    cout << "BFunc()" << endl;
}

string B::ToString() const
{
    cout << "B" << endl;
}

// Here is how add the member function pointers in the map
A a;
B b;

mapOfMethodPointers[*a] = &A::AFunc;
mapOfMethodPointers[*b] = &B::BFunc;

When I add both of the member function pointers in the map I get the following errors:

Can't convert 'void (B::*)()' to 'void (Object::*)()'
Can't convert 'void (A::*)()' to 'void (Object::*)()'

Regardless of the fact that both class A and class B are Objects, I can't make this convertions. How can I achieve such thing? I need something like polymorphism for member function pointers. The implementation I chose doesn't work. Any ideas?

Can you show the code where you try to add the functions to the map? — dlf, Aug 12 '14 at 13:24
question appears already asked and answered at http://stackoverflow.com/questions/10066731/how-to-register-a-derived-class-member-function-pointer-with-a-base-class . — Jordan Samuels, Aug 12 '14 at 13:26
I'd also be curious to know what higher level goal you are achieving with this. It seems possible to me that you might achieve it another way than with method pointers. What more can you tell us? — Jordan Samuels, Aug 12 '14 at 13:27
FWIW, I suspect you'd be better off using `std::function` in the map and either lambdas or `std::bind`ings for the assignments. — dlf, Aug 12 '14 at 13:30
I am gonna check that out. I have never used std::function or std::bind — Denis Rizov, Aug 12 '14 at 13:34
Thanks @JordanSamuels, I will see if the other post is helpful to me :) — Denis Rizov, Aug 12 '14 at 13:35

score 5 · Accepted Answer · answered Aug 12 '14 at 13:39

In order to do this all my classes inherit an Object class which only has default constructor, virtual destructor and a virtual ToString() const method.

This is a bad solution for storing polymorphic functions with similar signatures.

Here are two better solutions:

'1. Implement your function pointers as specializations of a base interface (Object in your case). Then, in the client code store the interfaces themselves:

struct Object { virtual void Execute() = 0; }

/// old: map<Object*, void (Object::*)()> mapOfMethodPointers;
/// new:
std::vector<Object*> objects;
objects[10]->Execute(); // execution is agnostic of whichever instance you you use

In this solution, Execute would resolve to A::Execute, as defined below:

class A : public Object
{
     void AFunc();
public:
    virtual void Execute() override { AFunc(); }
};

With this solution, you do not need a function map (because the virtual table of Object is essentially a function map).

'2. Implement your function map in terms of generic functions, then fill it with lambdas:

Code:

/// old: map<Object*, void (Object::*)()> mapOfMethodPointers;
/// new:
map<Object*, std::function<void()>> mapOfMethodPointers;

// filling the map:
class A // not needed: public Object
{
public:
    void AFunc(); // this is our interesting function

    string ToString() const override;
};

A obj;
mapOfMethodPointers[&obj] = [&obj]() { obj.AFunc(); };

Thanks, the second solution solved the problem for me. However I think I will stick with the first one, I think it's better. — Denis Rizov, Aug 12 '14 at 13:44

score 0 · Answer 2 · answered Oct 26 '18 at 17:09

You have to cast the derived member functions to base class member functions. The syntax for this is a bit clunky but perfectly logical. One restriction is that the base class can't be abstract.

Here is an example:

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

using namespace std;

class plant
{
public:
    map<string, void(plant::*)(void)> _action;
    void Action(string action);
};

void plant::Action(string action)
{
    (this->*_action[action])();
}

class flower: public plant
{
public:
    flower(void);
    void look_at(void);
    void smell(void);
    void pick(void);
};

flower::flower(void)
{
    _action["look at"] = (void(plant::*)(void))&flower::look_at;
    _action["pick"]    = (void(plant::*)(void))&flower::pick;
    _action["smell"]   = (void(plant::*)(void))&flower::smell;
}

void flower::look_at(void)
{
    cout << "looking at flower" << endl;
}

void flower::smell(void)
{
    cout << "smelling flower" << endl;
}

void flower::pick(void)
{
    cout << "picking flower" << endl;
}

int main()
{
    plant *myplant = new flower();

    myplant->Action("look at");
    myplant->Action("pick");
    myplant->Action("smell");

    delete myplant;
}

C++ map of member function pointers of different classes

2 Answers2