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

#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;
 
 }

IBase* ptr = new Concrete(); //указатель на базовый класс 
                                        //нацелился на объект потомка.
 
ptr -> VirtualMethod(); //пожалста. Запускай любые 
                                //виртуальные методы потомка

class base {
 
public:
    virtual void f()  {
 
    }
};
 
class C:public base {
 
public:
    void f() {
 
    }
    virtual void f2() {
    }
};
 
void main() {
 
    base *c = new C;
    c->f2();
}

struct base 
{
    base() { con <<"конструктор base"<<eEndl;} 
    base(int a) { con <<"конструктор base: "<<a<<eEndl;} 
};
 
struct derived:base
{ 
    derived():base(333)   //конструктор потомка толкает вперед себя 
                                 //конструктор предка в аргументом
    { con <<"конструктор derived"<<eEndl;} 
};
 
int main()
{
    STD; 
    
    derived rr; //конструктор base: 333
                //конструктор derived
}

#include <iostream>
#include <ctime>
#include <cstdlib>
 
class Base {
 public:
  virtual void foo() { std::cout << "Base" << std::endl; }
};
 
class A : public Base {
 public:
  virtual void foo() { std::cout << "A" << std::endl; }
};
 
class B : public Base {
 public:
  virtual void foo() { std::cout << "B" << std::endl; }
};
 
int main() {
  srand(time(0));
  Base *a;
  if (rand() % 2) 
    a = new A();
  else
    a = new B();
  a->foo();
  // в следующих трех выражениях будет вызвана одна и та же функция
  ((A*)a)->foo();
  ((B*)a)->foo();
  ((Base*)a)->foo();
  delete a;
}