Как вернуть обьект тип которого заранее неизвестно

#include <iostream>
#include <memory>
 
class Variant {
 
private:
    
    class base {
 
    public:
 
        base() {
 
            std::cout <<"base constr" << std::endl;
        }
        virtual ~base(){
            std::cout <<"base destr" << std::endl;
        };
 
    };
 
    template<class T>
    class type:public base {
 
    private:
        T object;
    public:
        type(T const& ob) {
            object = ob;
            std::cout <<"type constr" << std::endl;
        }
 
        T Get() {
            return object;
        }
 
        ~type() {
 
            std::cout <<"type destr" << std::endl;
        }
    };
 
    std::auto_ptr<base> pObject;
 
public:
 
    Variant() {
        std::cout <<"Vari2 constr" << std::endl;
 
    }
    
    template<class T>
    Variant(T  ob) {
        std::cout <<"Vari constr" << std::endl;
        pObject = std::auto_ptr<type<T>>(new type<T>(ob));
    }
 
    template<class T>
    Variant& operator = (T const&t) {
 
        pObject = std::auto_ptr<type<T>>(new type<T>(t));
        return *this;
    }
 
    template<class T>
    operator T() {
 
        type<T> &t = dynamic_cast<type<T>&>(*pObject);
        return t.Get();
    }
 
    ~Variant() {
 
        std::cout <<"Vari dest" << std::endl;
        
    }
};
 
 
class out_of_range : public std::exception {
 
public:
    out_of_range() { }
};
 
template<class Node, class T>
class iterator {
    
private:
    Node *current;
    
public:
    iterator(Node *node):current(node) { }
    
    void operator++() {
 
        if(!current)
            throw new out_of_range();
 
        current = current->getNext();
    }
 
    bool operator == (iterator const &other) {
 
        return current == other.current;
    }
 
    bool operator !=(iterator const &other) {
        
        return current != other.current;
    }
 
    Node* operator->() {
 
        return current;
    }
};
 
 
template<class T>
class node {
 
private:
    T value;
    node *next;
    node *prev;
public:
    node(T value) {
        next = NULL;
        prev = NULL;
        this->value = value;
    }
    
    node* getNext() {
        return next;
    }
 
    node* getPrev() {
        return prev;
    }
 
    void setPrev(node *n) {
        prev = n;
    }
    void setNext(node *n) {
        next = n;
    }
    T getValue() {
        return value;
    }
};
        
template<class T> 
class list {
 
public:
    typedef iterator<node<T>, T> iterator;
 
private:
    node<T> *root;
 
public:
    list():root(NULL) { };
 
    void push_back(T &value) {
 
        if(root) {
 
            node<T> *temp = root;
            while(temp->getNext()) {
                temp = temp->getNext();
            }
            temp->setNext(new node<T>(value));
            temp->getNext()->setPrev(temp);
 
        }else {
            root = new node<T>(value);
        }
 
    }
    
    T pop_back() {
 
        if(!root) 
            throw new out_of_range();
 
        if(!root->getNext()) {
            T value = root->getValue();
            delete root;
            root = NULL;
            return value;
        } else {
 
            node<T> *del = root;
            while(del->getNext()) {
                del = del->getNext();
            }
 
            T value = del->getValue();
            del->getPrev()->setNext(NULL);
            delete del;
            return value;
        }
    }
 
    void push_front(T value) {
 
        if(!root) {
            root = new node<T>(value);
        } else {
 
            node<T> *newnode = new node<T>(value);
            newnode->setNext(root);
            root->setPrev(newnode);
            root = newnode;
        }
    }
 
    T pop_front() {
 
        if(!root) 
            throw new out_of_range();
 
        if(!root->getNext()) {
            T value = root->getValue();
            delete root;
            root = NULL;
            return value;
        }else {
 
            T value = root->getValue();
            node<T> *newroot = root->getNext();
            delete root;
            root = newroot;
            root->setPrev(NULL);
            return value;
        }
    }
 
        
    iterator begin() {
 
        return iterator(root);
    }
 
    iterator end() {
        return iterator(NULL);
    }
 
    ~list() {
 
        while(root) {
 
            node<T> *del = root;
            root = root->getNext();
            delete del;
        
        }
    }
 
};
 
 
 void main() {
 
     {
        list<Variant> any;
        Variant var(1);
        any.push_back(var);
     }
 
 
    //any.push_back('a');
    ///any.push_back(3.14);
    //any.push_back(std::string("vasa"));
 
 
    // for(list<Variant>::iterator it = any.begin(); any.end() != it; it++);
    //   std::cout << it->getValue() << std::endl;
 
 }

BaseObject* f() 
{
   if (rand % 2) return new Derived1();
   else             return new Derived2();
}

class Cvariant
{
public:
    Cvariant(){}
    Cvariant(const Cvariant& src) { ptr=src.ptr; }
    template <class T> Cvariant& operator = (T const& t){ptr =(void*) &t; return *this;}
    template <class T> operator T(){ return *((T*)ptr); }
private:
    void* ptr;
};

MyClass obj1;
typeof(obj1) obj2; //typeof вернёт тип объекта obj1. 
        //Получится, что obj2 будет создан такого же типа, как и тип obj1