Динамическая проверка отливки из пустоты*

dynamic_cast используется для приведения полиморфного объекта к классу, который имеет тип объекта, который вы пытаетесь преобразовать, в качестве его родителя.

void* полностью отличается от этого. с указателем на void вы буквально удаляете информацию о каждом типе.

dynamic_cast знают, что есть базовый класс, и могут выполнять проверку типов через RTTI.

Когда вы сбрасываете пустой указатель, вы говорите компилятору: «Да, вы знаете это место в памяти? Ну, используйте его как этот тип», и если память недействительна, вызывается UB.

у вас есть три варианта здесь.

Вариант 1 Используйте интерфейс. Что ж, полиморфный базовый класс — единственный способ сделать dynamic_cast. Другого пути нет, никаких хаков, это единственный путь. Просто как тот.

struct Base { virtual ~Base() = default; };

struct Derived : Base {};

// ...

void test (Base* base) {
    auto derived = dynamic_cast<Derived*>(base);

    if (derived) {
        // derived is valid here.
    }
}

Вариант 2 Определите тип с помощью указателя. Я использую метод, чтобы иметь уникальный идентификатор для каждого типа и использовать идентификатор для проверки приведения. Сделано без RTTI

using type_id_t = void(*)();
template <typename T> void type_id() {}

// now we can use a map or a vector.
std::vector<std::pair<type_id_t, void*>> vec;

template<typename T>
void insertToMyVector(T* obj) {
    vec.emplace_back(type_id<T>, obj);
}

template<typename T>
T* getObj(int index) {
    auto item = vec[index];

    return static_cast<T*>(item.first == &type_id<T> ? item.second : nullptr);
}

// ...

int main () {
    auto foo = new Foo;

    insertToMyVector(foo);

    auto maybeFoo = getObj<Foo>(0);

    if (maybeFoo) {
        // you have a valid Foo here
    }
}

Вариант 3. Создание производного класса для любого типа. Этот вариант весьма полезен, поскольку он может содержать любой тип, сохраняя при этом безопасность типов. Я похож на решение 1, но предлагаю больше гибкости. Хитрость заключается в создании производного класса для любого типа с использованием шаблонов. Преимущество в том, что вы можете держать любой тип, но это может немного усложнить вам обучение.

struct Base { virtual ~Base() = default; };

template<typename T>
struct Derived : Base {
    Derived(T&& obj) : _obj{std::move(obj)} {}
    Derived(const T& obj) : _obj{obj} {}

    T& get() {
        return _obj;
    }

    const T& get() const {
        return _obj;
    }

private:
    T _obj;
};

// ...

void test (Base* base) {
    auto derived = dynamic_cast<Derived<int>*>(base);

    if (derived) {
        int i = derived->get();
        // derived is valid here, and we can safely access the int
    }
}

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

#include <cassert>

class Bar
{
public:
    Bar() = default;
     virtual ~Bar() = default;
};

class Foo : public Bar
{
public:
    Foo() = default;
    virtual ~Foo() = default;
};

int main()
{
    Bar* bar = new Foo;
    Foo* foo = dynamic_cast<Foo*>(bar);
    assert(foo != nullptr);
}

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

Для этого уже есть довольно стандартная идиома — она называется boost::any.

boost::any содержит ваш объект плюс некоторую информацию о типе. Интерфейс позволяет вам запрашивать тип и пытаться привести любой к типу, который вы ищете.

http://www.boost.org/doc/libs/1_59_0/doc/html/any.html