Использование RTTI для определения графика наследования в С++?

Ответ 1

У меня была аналогичная проблема, которую я решил через исключения! Я написал статью об этом:

http://drdobbs.com/cpp/229401004

Ok. Следуя совету Питера, набросок идеи следует. Он полагается на то, что если D происходит от B и вызывается указатель на D, тогда будет активировано предложение catch, ожидающее указателя на B.

Затем можно написать класс (в моей статье я назвал его any_ptr), конструктор которого принимает T* и сохраняет его копию как void*. Класс реализует механизм, который статически ставит void* в его исходный тип T* и выдает результат. Предложение catch, ожидающее U*, где U= T или U является базой T, будет активировано, и эта стратегия является ключом к реализации теста, как в исходном вопросе.

РЕДАКТИРОВАТЬ: (по Маттиу М. для ответов лучше всего автономно, пожалуйста, обратитесь к доктору Добсу за полный ответ)

class any_ptr {

    void* ptr_;
    void (*thr_)(void*);

    template <typename T>
    static void thrower(void* ptr) { throw static_cast<T*>(ptr); }

public:

    template <typename T>
    any_ptr(T* ptr) : ptr_(ptr), thr_(&thrower<T>) {}

    template <typename U>
    U* cast() const {
        try { thr_(ptr_); }
        catch (U* ptr) { return ptr; }
        catch (...) {}
        return 0;
    }
};

Ответ 2

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

Пример для gcc с использованием Itanium ABI:

#include <cassert>
#include <typeinfo>
#include <cxxabi.h>
#include <iostream>

bool is_ancestor(const std::type_info& a, const std::type_info& b);

namespace {
  bool walk_tree(const __cxxabiv1::__si_class_type_info *si, const std::type_info& a) {
    return si->__base_type == &a ? true : is_ancestor(a, *si->__base_type);
  }

  bool walk_tree(const __cxxabiv1::__vmi_class_type_info *mi, const std::type_info& a) {
    for (unsigned int i = 0; i < mi->__base_count; ++i) {
      if (is_ancestor(a, *mi->__base_info[i].__base_type))
        return true;
    }
    return false;
  }
}

bool is_ancestor(const std::type_info& a, const std::type_info& b) {
  if (a==b)
    return true;
  const __cxxabiv1::__si_class_type_info *si = dynamic_cast<const __cxxabiv1::__si_class_type_info*>(&b);
  if (si)
    return walk_tree(si, a);
  const __cxxabiv1::__vmi_class_type_info *mi = dynamic_cast<const __cxxabiv1::__vmi_class_type_info*>(&b);
  if (mi)
    return walk_tree(mi, a);
  return false;
}

struct foo {};

struct bar : foo {};

struct baz {};

struct crazy : virtual foo, virtual bar, virtual baz {};

int main() {
  std::cout << is_ancestor(typeid(foo), typeid(bar)) << "\n";
  std::cout << is_ancestor(typeid(foo), typeid(baz)) << "\n";
  std::cout << is_ancestor(typeid(foo), typeid(int)) << "\n";
  std::cout << is_ancestor(typeid(foo), typeid(crazy)) << "\n";
}

Где я применяю type_info к реальному типу, который используется внутренне, а затем рекурсивно используется для перемещения дерева наследования.

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

Ответ 3

Во-первых, то, что вы просите, не может быть реализовано только поверх type_info.

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

Единственный способ безопасно отличить значение от типа к другому - это использовать static_cast (работает для одиночного или множественного наследования) и dynamic_cast (также работает для виртуального наследования и фактически проверяет значения времени выполнения).

К сожалению, это фактически несовместимо с стиранием типа (старая template-virtual несовместимость).

Если вы ограничиваете себя не виртуальным наследованием, я думаю, что это должно быть возможным для этого, сохраняя смещения преобразований на различные базы в некоторых Configuration данных (о синглтонах, о которых вы говорите).

Для виртуального наследования я могу только думать о карте пар type_info в void* (*caster)(void*).

И все это требует перечисления возможных бросков вручную: (

Ответ 4

Невозможно использовать std::type_info, так как он не предоставляет способ запроса информации наследования или преобразования объекта std::type_info в соответствующий тип, чтобы вы могли сделать трансляцию.

Если у вас есть список всех возможных типов, которые необходимо сохранить в ваших объектах any, используйте boost::variant и его посетителя.

Ответ 5

Хотя я не могу придумать какой-либо способ реализации опции №1, вариант №2 должен быть осуществимым, если вы можете сгенерировать список времени компиляции классов, которые вы хотели бы использовать. Отфильтруйте этот список типов с помощью boost:: MPL и метафайла is_base_of, чтобы получить список допустимых типов типов, которые можно сравнить с сохраненным типом.