Использование родительского класса для доступа к элементам контейнера

class ADT
{
private:
    bool forSafe;
public:
    friend std::ostream& operator<<(std::ostream& left, ADT right) { return left; };
    friend std::istream& operator>>(std::istream& left, ADT right) { return left; };
};

#include <iostream>
#include <memory>
 
class Base
{
public:
    virtual ~Base() = default;
 
    virtual Base* clone() const = 0;
 
    virtual std::ostream & print(std::ostream& out) const = 0;
 
    friend std::ostream& operator<<(std::ostream& out, Base const& x)  {
        return x.print(out);
    }
};
 
class List
{
    struct Node
    {
        explicit Node(std::unique_ptr<Base>&& data, Node* next = nullptr)
            : data(std::move(data)), next(next)
        { }
 
        std::unique_ptr<Base> data;
        Node* next;
    };
public:
    class Iterator
    {
        friend class List;
    private:
        explicit Iterator(Node* n = nullptr) : np(n)
        { }
    public:
        Iterator& operator++() {
            np = np->next;
            return *this;
        }
        Base& operator*() {
            return *np->data;
        }
        Base const& operator*() const {
            return *np->data;
        }
 
        bool operator!=(Iterator const& left) const {
 
            return np != left.np;
        }
        bool operator==(Iterator const& left) const {
 
            return np == left.np;
        }
    private:
        Node* np;
    };
 
    List();
    ~List();
 
    void Add(Base const& x);
 
    Iterator begin() {
        return Iterator(head);
    }
    Iterator end() {
        return Iterator();
    }
 
    void clear();
 
private:
    Node* head;
    Node* tail;
};
 
List::List() : head(), tail()
{ }
List::~List() {
    clear();
}
 
void List::clear() {
    Node* cur = head;
    while(cur) {
        Node *del = cur;
        cur = cur->next;
        delete del;
    }
    head = tail = nullptr;
}
 
void List::Add(Base const& x) {
    std::unique_ptr<Base> data(x.clone());
 
    Node* node = new Node(std::move(data));
    if(head) {
        tail->next = node;
    }
    else {
        head = node;
    }
    tail = node;
}
//===================================================
 
class Derived1 : public Base {
public:
    Derived1(int v) : data(v) {}
 
    virtual Base* clone() const {
        return new Derived1(*this);
    }
    virtual std::ostream& print(std::ostream& out) const {
        return out << data;
    }
 
private:
    int data;
};
class Derived2 : public Base {
public:
    Derived2(double v) : data(v) {}
 
    virtual Base* clone() const {
        return new Derived2(*this);
    }
    virtual std::ostream& print(std::ostream& out) const {
        return out << data;
    }
 
private:
    double data;
};
 
int main()
{
    List lst;
 
    lst.Add(Derived1(1));
    lst.Add(Derived2(3.14));
    lst.Add(Derived1(3));
 
    for(auto &v : lst) {
        std::cout << v << std::endl;
    }
}