Question

I have an abstract type A, and two derived types A1 and A2.
I want to add a method M to class A, which takes a parameter of type A. But, I need ad hoc polymorphism.

Indeed, I need 3 implementations : A1::M(A1 a), A1::M(A2 a) and A2::(A1 a), A2::M(A2 a).
But I want an abstract way to call the method M with pointers of type A.

I could put all signatures declaration in class A, but it sucks.

Answer 1

This is double dispatch. When you write:

A* p1;
A* p2;
p1->M(*p2);

should dispatch both on the type of *p1 and the type of *p2.

Before starting, you must realize that this means n^2 functions for
n different derived types. And that somewhere, someone must be aware
of all of the derived types (unless you can define some sort of
“default” implemenation for an unknown pair of types).

There are two ways of implementing this. The simplest, if the hierarchy
is closed (i.e. client code cannot introduce new derived classes) does
use a host of virtual functions in the base class—generally
protected, since they’re not designed to be called outside the
hierarchy:

//  Forward references needed for all derived classes...
class A1;
class A2;
//  ...

class A
{
protectd:
    virtual void doM(A1* arg) = 0;
    virtual void doM(A2* arg) = 0;
    //  ...

public:
    virtual void M(A& arg) = 0;
};

In the derived classes, the implementation of M is always the same:

void A1::M(A& arg)
{
    arg.doM( this );
}

This is simple, and relatively efficient, but requires changes in the
abstract base and all of the derived classes (which have to implement
the new virtual function) each time you add a new derived class. It’s
useful for closed hierarchies, however; I’ve used it in classes using
the strategy pattern for part of their behavior, where the various
strategies were all defined in the source file, and not exposed to the
clients (and the abstract base of the strategies was only forward
declared in the header, so no header changes were necessary if I added a
strategy).

A more general solution would involve an std::map, with a pair of
typeid as index. You can’t use typeid directly, since it’s not
copyable. C++11 provides a type_index to wrap it; if you’re using an
older compiler, it’s fairly trivial to implement one yourself. The
basic principle is something along the lines of (probably in A itself):

typedef std::pair<std::type_index, std::type_index> TypePairKey;
typedef void (*FuncPtr)( M* arg1, M* arg2 );
typedef std::unordered_map<TypePairKey, FuncPtr> DispatchMap;

static DispatchMap ourDispatchMap;

with:

void M( A& arg )        //  NOT virtual !!!
{
    DispatchMap::iterator entry
        = ourDispatchMap.find(
                DispatchMap::value_type( typeid( *this ), typeid( arg ) ) );
    assert( entry != ourDispatchMap.end() );
        //  Or some default handling, maybe throw NotYetImplemented()
    (*entry->second)( this, &arg );
}

The real problem comes with writing each of the individual functions and
inserting their addresses in the map (before first use). The functions
themselves, of course, can use dynamic_cast, or even static_cast, if
you can be sure that they will only be called from here, and they can be
friend(s) of the class(es) involved, but there are still
n² of them. (One frequent solution is to make them
static members of one of the classes, and to have each derived class
define a static member of a type which does the registration of all of
the functions its responsible for.)