Как записать собственный dynamic_cast

Чтобы попытаться ответить на этот вопрос чуть менее рутинно, если чуть менее определенно:

Что вам нужно сделать, так это привести указатель к int*, создать новый тип T на стеке, привести указатель на него к int*, и сравнить первый int в обоих типах. При этом будет выполнено сравнение адресов в таблице. Если они одного типа, то у них будет одна и та же таблица. В противном случае - нет.

Более разумные из нас просто вставляют интегральную константу в наши классы.

Легко. Получите все объекты из некоторого интерфейса typeid с помощью виртуальной функции WhoAmI (). Переопределите его во всех производных классах.

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

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

Хорошей реализацией может быть шаблонный класс:

template <typename T>
class ClassId<T>
{
    public:

    static int GetClassId() { return (sClassId); }

    virtual int GetClassId() const { return (sClassId); }

    template<typename U> static void StateDerivation() {
        gClassMap[ClassId<T>::GetClassId()].push_back(ClassId<U>::GetClassId());
    }

    template<typename U> const U DynamicCast() const {
        std::map<int, std::list<int>>::const_iterator it = gClassMap.find(ClassId<T>); // Base class type, with relative derivations declared with StateDerivation()
        int id = ClassId<U>::GetClassId();

        if (id == ClassId<T>::GetClassId()) return (static_cast<U>(this));

        while (it != gClassMap.end()) {
            for (std::list<int>::const_iterator = pit->second.begin(), pite = it->second->end(); pit != pite; pit++) {
                if ((*pit) == id) return (static_cast<U>(this));
                // ... For each derived element, iterate over the stated derivations.
                // Easy to implement with a recursive function, better if using a std::stack to avoid recursion.
            }
        }

        return (null); 
    }  

    private:

    static int sClassId;
}

#define CLASS_IMP(klass) static int ClassId<klass>::sClassId = gClassId++;

// Global scope variables    

static int gClassId = 0;
static std::map<int, std::list<int>> gClassMap;

CLASS_IMP должен быть определен для каждого класса, производного от ClassId, а gClassId и gClassMap должны быть видимы в глобальной области.

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

Для представления иерархии классов достаточно сопоставления идентификатора класса и его производных классов. Чтобы узнать, можно ли отнести какой-либо класс к определенному классу, выполните итерацию по карте и проверьте производные объявления.

Есть много трудностей, с которыми приходится сталкиваться ... использование ссылок! виртуальные производные! плохой кастинг! Неправильная инициализация сопоставления типов классов приведет к ошибкам приведения типов ...

Отношения между классами должны определяться вручную, жестко запрограммированные с помощью процедуры инициализации. Это позволяет определить, является ли класс производным от или два класса как общие производные.

class Base : ClassId<Base> {  }
#define CLASS_IMP(Base);
class Derived : public Base, public ClassId<Derived> {  }
#define CLASS_IMP(Derived);
class DerivedDerived : public Derived, public ClassId<DerivedDerived> {  }
#define CLASS_IMP(DerivedDerived);

static void DeclareDerivations()
{
    ClassId<Base>::StateDerivation<Derived>();
    ClassId<Derived>::StateDerivation<DerivedDerived>();
}

Лично я согласен с тем, что «есть причина, если компиляторы реализуют dynamic_cast»; возможно, компилятор делает это лучше (особенно в отношении кода примера!).