How to assign method member pointer of a subclass?

Question

My problem is a bit complicated. I have one class (e: Component) which have Ports objects. When a Component create a Port object, it pass one of its methods to the Port constructor.

Methods signatures :

typedef std::vector<std::string> (Component::*ComponentMethod)(std::vector<std::string>);

It works fine if I do :

// in class Component

std::vector<std::string> Component::test_method( std::vector<std::string> ) {
    std::cout << "Hello !\n";
    // Do stuff
}

// Port ctor : Port( ComponentMethod callback );
Port* p = new Port(&Component::test_method);

Well... now, my problem is that I make subclasses of class Component, and I don't know how to pass sublcasses methods to a Port.

// in class SubtypeComponent

std::vector<std::string> SubtypeComponent::test_method2( std::vector<std::string> ) {
    std::cout << "Hello !\n";
    // Do stuff
}

// Port ctor : Port( ComponentMethod callback );
Port* p = new Port(&SubtypeComponent::test_method2);
// ERROR :'(

It seems normal : I guess the compiler expects precisely Component (only) method.

--> I'm looking for a solution to "dynamically" assign methods in Ports (but I don't think this is possible)

--> Maybe another solution should be usage of templates ? (defining "template methods pointers" instead of "Component methods pointers"), but I'm not sure.

Any help would be appreciated :)

Answer 1

The easiest way to do it would probably be if you let Component have a virtual method called for example test_method. Then you could pass a pointer to a Component to the constructor of Port and then Port could just call this virtual method:

Component* c = new Component();
// Port ctor : Port( Component* component );
Port* p = new Port(c); // Port would then call c->test_method();

or

SubtypeComponent* sc = new SubtypeComponent();
// Port ctor : Port( Component* component );
Port* p = new Port(sc); // Port would then call sc->test_method();

However if for some reason this doesn't give you enough flexibility there is another way to solve your problem: you need to pass a type instead of the method pointer. This type then holds the method (and an object because you can't call a method without an object). Here is an example of this type (you can also use the std::function if you have C++11 available):

class Handler {
    public:
    virtual std::vector<std::string> handle (std::vector<std::string> arguments) = 0;
};

template <class C> class Method: public Handler {
    C* object;
    std::vector<std::string> (C::*method) (std::vector<std::string>);
    public:
    Method (C *object, std::vector<std::string>(C::*method)(std::vector<std::string>)) {
        this->object = object;
        this->method = method;
    }
    virtual std::vector<std::string> handle (std::vector<std::string> arguments) {
        // call the method
        return (object->*method) (arguments);
    }
};

Now you modify your Port class constructor to take a pointer to a Handler as an argument. Then you can write:

Component* c = new Component();
// Port ctor : Port( Handler* handler );
Port* p = new Port(new Method<Component>(c, &Component::test_method));

and

SubtypeComponent* sc = new SubtypeComponent();
// Port ctor : Port( Handler* handler );
Port* p = new Port(new Method<SubtypeComponent>(sc, &SubtypeComponent::test_method2));

Also have a look at these questions:
C++ member function pointers in class and subclass
Method pointer casting

Answer 2

You can with a template adapter, since pointers-to-members can be casted, that way:

struct Base {
  bool foo(int);
};

struct Child : Base {
  bool foo(int);
};

// real functional type
using Function = std::function<bool(Base*,int)>;
// adapter template for children classes member functions
template <class T>
using MemberFunction = (T::*)(int);

// real user function
void user(Function function);
// adapter template for children classes member functions
template <class T>
void user(MemberFunction<T> function) {
  // pointers-to-members can be casted
  user(static_cast<MemberFunction<Base>>(function));
}

Answer 3

The conversions for pointer-to-member are a bit counter intuitive at first. A pointer-to-member that refers to a base member can be implicitly converted to a pointer-to-member to a derived type (contra variance), but the opposite is not true.

If you really think about it, it does make sense: if you have a pointer to a member of base, that can be applied to a derived type, since it is guaranteed to have a base subobject. On the contrary, a pointer to member that refers to derived type might be pointing to a member that was not present in the base type, and thus the conversion would not make sense.

This is the issue in your design that you must address, if you want to hold pointers-to-member referring to a base type, the pointers must refer to members present in the base (in which case the expression &derived::member is of type T base::* and there is no need to convert) and they must not have been previously stored in a pointer-to-member of derived type (after storing it, the compiler cannot know if the pointer refers to a member of base or a member of derived)

Answer 4

You clearly cannot convert a pointer to a member of a derived type to a pointer to a member of the base: This would allow calling a member of a derived type on a base object without upsetting the type system! If anything, the conversion should work the other way around, i.e., you might be able to convert a pointer to a member of a based to a pointer to a member of a derived type (however, I think this isn't possible, either, but I'm not sure).

The way to bypass this problem entirely is to use a type-erased function type to pass around. For example, you could use a std::function<std::vector<std::string>(std::vector<std::string>) and set it up to refernce your object. If you really need to pass in different objects as argument, you could pass a pointer or a reference to the base and dynamic_cast<D&>(r) it to the expected type (and deal with the exception if it ever gets called on the wrong object).