Указатель выдает мусорные значения при использовании виртуального наследования.

У меня есть класс хранения, который хранит указатели void (я знаю, что это спорный дизайн, но я его не разрабатывал) на произвольные типы данных. При написании модульного теста я заметил, что получаю ошибку сегментации, когда данные возвращаются из хранилища. Используя отладчик MS Visual, я заметил, что значения в возвращаемом указателе все недопустимы. Кто-нибудь знает, почему? Это происходит только в том случае, если B виртуально унаследован от A. Есть ли способ заставить извлечение работать?

#include <iostream>
#include <compare>
#include <string>
#include <unordered_map>
#include <typeindex>
#include <memory>

    struct MapKey final
    {
        std::string name;
        std::type_index type;
    };

    std::strong_ordering operator<=>(const MapKey& lhs, const MapKey& rhs)
    {
        if (lhs.type < rhs.type)
        {
            return std::strong_ordering::less;
        }

        if (lhs.type > rhs.type)
        {
            return std::strong_ordering::greater;
        }

        return lhs.name <=> rhs.name;
    };

    bool operator==(const MapKey& lhs, const MapKey& rhs)
    {
        return (lhs <=> rhs) == std::strong_ordering::equal;
    }
    
    template <typename D>
    MapKey makeKey(D* data = nullptr)
    {
        auto const& type = (data == nullptr) ? typeid(D) : typeid(*data);
        std::string typen{type.name()};
        return MapKey{typen, type};
    }

    struct Hasher final
    {
        auto operator()(const MapKey& key) const -> size_t
        {
            return std::hash<std::type_index>{}(key.type) ^ std::hash<std::string>{}(key.name);
        }
    };

    class DataMap
    {
    public:
        template <typename D>
        void setData(std::shared_ptr<D> spData)
        {
            m_dataMap[makeKey<D>(spData.get())] = spData;
        } 

        template <typename D>
        [[nodiscard]] std::shared_ptr<D> getData() const
        {
            auto const data = m_dataMap.find(makeKey<D>());
            if (data != m_dataMap.end())
            {
                return std::static_pointer_cast<D>(data->second);
            }
            return nullptr;
        }

    private:
        using DATA_MAP = std::unordered_map<MapKey, std::shared_ptr<void>, Hasher>;
        DATA_MAP m_dataMap;
    };
    
class A
{
public:
    virtual size_t size() const
    {
        return 1;
    }
};
class B : virtual public A
{
public:
    size_t size() const override
    {
        return 2;
    }
};
    
int main()
{
    std::shared_ptr<A> spA = std::make_shared<B>(); // базовый указатель (требование)

    auto k1 = makeKey<A>(spA.get());
    auto k2 = makeKey<B>();

    auto h1 = Hasher()(k1);
    auto h2 = Hasher()(k2);

    auto const& tAB = typeid(*spA);
    auto const& tB = typeid(B);
    if (tAB != tB) {
        std::cout << "Разные типы для tAB & tB!"<< std::endl;
    }

    if (h1 != h2) {
        std::cout << "Разные хеши!"<< std::endl;
    }

    DataMap ds;
    ds.setData(spA);
    auto spGet = ds.getData<B>();

    auto const& tGet = typeid(*spGet);  // Ошибка сегментации
    if (tGet != tB) {
        std::cout << "Разные типы для tGet & tB!"<< std::endl;
    }

    if (spGet.get() != spA.get()) {
        std::cout << "Разные указатели!"<< std::endl;
    }

    if (spGet->size() != 2) {
        std::cout << "Разные размеры!"<< std::endl;
    }
}

Пытался не использовать виртуальное наследование для B. Указатель возвращался корректно.