Как запомнить тип данных, потом по запомненному типу создать объект?

std::function<void* ()> factory = [] () -> void* { return new MyType(); };

#include <iostream>
 
template<typename T>
struct holder
{
    template<typename ...Args>
    T create(Args&&... args)
    {
        return T(std::forward<Args>(args)...);
    }
};
 
struct MyType1
{
    int m_value;
    MyType1(int value) : m_value(value){std::cout << "created\n";}
};
 
int main()
{
    // сохранили тип
    holder<MyType1> h1;
    // создали объект
    MyType1 t1 = h1.create(100);
    std::cout << t1.m_value;
}

#include <iostream>
 
struct MyType1
{
    int m_value{};
    MyType1(int value) : m_value(value){std::cout << "created\n";}
};
 
int main()
{
    using h1=MyType1;
 
    h1 t1(100);
    std::cout << t1.m_value;
}

class Any {
template<typename dTYPE>
struct holder {
    template<typename ...Args>
    dTYPE create(Args&&... args){
        return dTYPE(std::forward<Args>(args)...);
    }
};
private:
    void* pnt;
public:
    template<typename dTYPE>
    Any(dTYPE obj){
        holder<dTYPE> hld;
        this->pnt=&hld;
    }
    template <typename dTYPE>
    explicit operator dTYPE() const{return *static_cast<dTYPE*>(this->pnt);}
};

using TypesList=std::variant<std::monostate,MyType1*,MyType2*,MyType3*,MyType4*>;

#include <iostream>
#include <variant>
 
struct MyType1{ void print()const{std::cout<<"MyType1"<<'\n';} };
struct MyType2{ void print()const{std::cout<<"MyType2"<<'\n';} };
struct MyType3{ void print()const{std::cout<<"MyType3"<<'\n';} };
struct MyType4{ void print()const{std::cout<<"MyType4"<<'\n';} };
 
using TypesList=std::variant<std::monostate,MyType1*,MyType2*,MyType3*,MyType4*>;
 
TypesList GetSomeType()
{
    //запоминаемый тип
    MyType3* p{};
    
    return TypesList{p};
}
 
int main()
{
    //получаем "сохранённый тип"
    auto list=GetSomeType();
    
    //создаём экземпляр сохранённого типа
    std::visit([](const auto& pointer)
    {
        using T=std::decay_t<decltype(pointer)>;
        if constexpr (!std::is_same_v<T,std::monostate>)
        {
            using MyTypeX=std::remove_pointer_t<T>;
            
            //создаём экземпляр
            MyTypeX variable{};
            
            //вызываем метод экземпляра
            variable.print();
        }
    },list);
}