Полиморфный (чистый абстрактный) ключ карты жертвует безопасностью типов?

В общем, ответ должен включать двойную отправку. Идея состоит в том, что если у вас n разные подклассы PacketInfo, вам понадобятся n * (n - 1) / 2 реализации оператора сравнения. В самом деле, что произойдет, если вы сравните CustomInfo с AwesomePersonalInfo? Для этого необходимо заранее знать всю иерархию, и пример кода представлен в этом вопросе SO .

Если вы уверены, что можете применить карту с идентичными типами внутри (и поэтому уверены, что вам нужны только реализации оператора n), тогда нет смысла иметь map<PacketInfo, X>. Просто используйте map<ConcretePacketInfo, X>.

Есть несколько способов сделать это. Самое простое, что можно сделать здесь, - это создать шаблон Processor для типа пакета, возможно, сделав его наследованием от класса BasicProcessor, если вы хотите где-то «стереть» параметр шаблона и учесть общий код.

Еще одно дешевое решение: оставить код как есть, но сделать Processor шаблон, который определяет только соответствующие addPacket:

class BasicProcessor
{
private:
    template <typename T> struct pless 
    {
        bool operator()(T const* a, T const* b) const 
        {
            assert(a && b);
            return *a < *b;
        }
    };

protected:
    std::map<PacketInfo const*, X, pless<PacketInfo>> packets;
};

// You only need these lines in a public header file.
template <typename Packet>
class Processor : public BasicProcessor
{
public:
     void addPacket(Packet const* p, X const& x)
     {
         this->packets[p] = x;
     }
};

Это гарантирует, что вызывающий абонент будет манипулировать объектом Processor<CustomPacket> и добавлять только правильный тип пакета. На мой взгляд, класс Processor должен быть классом-шаблоном.

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

Вы не можете. Вы либо знаете типы во время компиляции, либо проверяете их во время выполнения. Серебряной пули нет.

Самая очевидная проблема, которую я вижу, заключается в том, что ваши функции operator< и operator== не являются константными. Таким образом, вы не можете вызывать их через указатель на const или ссылку на const. Они должны быть:

virtual voie operator==(PacketInfo const& other) const = 0;
virtual voie operator<(PacketInfo const& other) const = 0;

Кроме того, логически, если вы определяете эти два, вы должны определить другие четыре. Обычно я с этим справляюсь, определяя полиморфную функцию-член compare, которая возвращает значение <, == или > 0, в зависимости от того, является ли ее объект this меньше, равен или больше, чем другой объект. Таким образом, производные классы должны реализовать только одну функцию.

Кроме того, вам определенно понадобится какой-то тип RTTI или двойная отправка, чтобы гарантировать, что оба объекта имеют один и тот же тип при их сравнении (и как вы заказываете сравнение, когда они этого не делают).