Сделать этот код правильно полиморфным

Ответ @imreal с использованием двойной отправки верен. Однако рассылки можно выполнять с использованием виртуальных функций-членов вместо карты и указателей на функции (что на самом деле похоже на виртуальную таблицу, которую генерирует компилятор).

Проблема в том, что одна виртуальная функция не решит проблему, потому что вам действительно нужна двойная диспетчеризация (т.е. виртуальный вызов в отношении обоих объектов, а не только вызываемого).

См. следующий рабочий пример:

#include <iostream>

class Child1;
class Child2;

class Parent
{
public:
    virtual void interact_with(Parent* other) = 0;
    virtual void interact_with(Child1* child) {};
    virtual void interact_with(Child2* child) {};
};

class Child1 : public Parent
{
public:
    virtual void interact_with(Parent* other)
    {
        other->interact_with(this);
    }
    virtual void interact_with(Child1* child)
    {
        std::cout << "Child1 - Child1\n";
    }
    virtual void interact_with(Child2* child)
    {
        std::cout << "Child1 - Child2\n";
    }
};

class Child2 : public Parent
{
public:
    virtual void interact_with(Parent* other)
    {
        other->interact_with(this);
    }
    virtual void interact_with(Child1* child)
    {
        std::cout << "Child2 - Child1\n";
    }
    virtual void interact_with(Child2* child)
    {
        std::cout << "Child2 - Child2\n";
    }
};

int main()
{
    Child1 c1;
    Parent* p1 = &c1; // upcast to parent, from p1, we don't know the child type
    Child2 c2;
    Parent* p2 = &c2;

    c1.interact_with(&c2); // single virtual call to Child1 - Child2
    p1->interact_with(&c2); // single virtual call to Child1 - Child2
    p1->interact_with(p2); // double virtual call to Child2 - Child1 (NB: reversed interaction)
}

Он выводит:

Child1 - Child2
Child1 - Child2
Child2 - Child1

Обратите внимание, что последний перевернут. Это потому, что для динамической отправки с использованием виртуальных функций для аргумента мне нужно поменять местами указатель this с аргументом. Это нормально, если эти взаимодействия симметричны. Если это не так, то я бы предложил создать оболочку вокруг самой общей, снова заменив this и аргумент.

_{Предупреждение: это решение нарушит работу ваших интерфейсов. Но не волнуйтесь, они уже сломаны ;)}

На мой взгляд, ваша ошибка проектирования заключается в следующем: хотя все дети «равны», вы выбираете одного из них, который будет отвечать за взаимодействия, и вызываете на нем метод (и если вы хотите 3, 4, ..., N равных детей (в массив) для одновременного взаимодействия, какой из них отвечает?)

Если в вашем приложении все объекты одинаково важны и ни один объект не отвечает за взаимодействия, вам следует перенести взаимодействия в свободные перегруженные бинарные функции:

void interact(Child1* a, Child1* b);

void interact(Child1* a, Child2* b);

...

void interact(Child2* a, Child1* b)
{
    interact(b, a); // if order does not matter, reuse another function 
}

Ясно, что это не решит проблему шаблонного кода, но, по крайней мере, может помочь вам переосмыслить свой дизайн и найти лучшее решение, чем двойная диспетчеризация или приведение типов.

Кроме того, в зависимости от внутреннего устройства функций вы, вероятно, могли бы легко сократить объем написанного (но не размер кода), используя шаблонные функции вместо перегруженных.

Как вы сказали, такое использование dynamic_cast‹> — плохой дизайн. Вы должны сделать функцию interface_with виртуальной в объявлении.

virtual void interact_with(Parent foo);

Это заставит вызов метода использовать реализацию интерактивного_с подкласса вместо реализации родительского класса. Затем вы можете заменить все, что вы написали, только этим.

interact_with(foo);

Вот довольно хорошее объяснение виртуальных методов.

Вам нужна двойная отправка

Существует множество подходов, которые вы можете использовать в зависимости от ваших требований. Очень общим является наличие простой карты формы Ключ (тип, тип) -> Значение (функция), которая связывает пару типов аргументов с вызываемой функцией.

В этом случае вам понадобится набор бесплатных функций типа void function(Parent*, Parent*) (по одной для каждой необходимой вам комбинации) и карта типа std::unordered_map<std::pair<TypeId, TypeId>, FunctionType>, где TypeId — некоторая форма идентификатора типа с семантикой значений.

Затем вы выполняете отправку во время выполнения:

if(map_.find(make_pair(type1, type2)) != map_.end())
    map_[make_pair(type1, type2)](obj1, obj2);

Не перед регистрацией каждой функции:

map_[make_pair(type1, type2)] = func12;
map_[make_pair(type2, type3)] = func23;
....