Хочу перегрузить iterator для пользовательского шаблонного класса контейнера

std::list<int>::iterator it = list2.begin();

Array<int>::iterator it = array0.begin();

template <typename T, class Allocator = std::allocator<T>>
class Array
{
public:
    //   конструктор класса
    explicit Array(size_t size, const T& value = T());
 
    //   конструктор по умолчанию
    Array();
 
    //   деструктор
    ~Array();
 
    //   конструктор копирования
    Array(const Array & other);
    Array(const std::vector<T> & other);
 
    //   оператор присваивания
    Array& operator=(const Array & other);
 
    void swap(Array &other);
//   возвращает размер массива (количество элементов).
size_t size() const;
//T * data() const { return data_; };
 
//   две версии оператора доступа по индексу
T& operator[](size_t i);
const T& operator[](size_t i) const;
 
T& get(size_t i) { return data_[i]; };
const T& get(size_t i) const { return data_[i]; };
 
T& at(size_t i) { return data_[i]; };
const T& at(size_t i) const { return data_[i]; };
 
T* begin() { return &data_[0]; }
T* end() { return &data_[size_]; }
 
private:
    size_t size_;
    T * data_;
 
};

// пример использования:
 
#include <tools/iteratos.hpp> // <--- допустим здесь живут наши итераторы
 
#include <iostream>
#include <memory>
#include <string>
#include <list>
 
// <--- пример рекурсивного деревца
    class form
    {
        using sform          = ::std::shared_ptr<form>;
        using container      = ::std::list<sform>;
        
        // iterator`s contract
        dDECLARE_FRIEND_ITERATORS(form);
        container&       get_container()      { return m_container; }
        const container& get_container()const { return m_container; }
 
        static const form* get_pointer(const container::const_iterator& it)
            { return (*it).get(); }
        
    public:
        // рекурсивные
        using iterator       
            = ::tools::recursieve_iterator<form>;
        
        using const_iterator 
            = ::tools::recursieve_iterator<const form>;
        
        // не рекурсивные
        using non_rec_iterator       
            = ::tools::iterator<form>;
        
        using const_non_rec_iterator 
            = ::tools::iterator<const form>;
        
    public:
        // iterator`s contract
        auto begin() { return iterator(*this); }
        
        auto begin() const { return const_iterator(*this); }
        
        auto end()   
            { return iterator(*this, false); }
        
        auto end() const
            { return const_iterator(*this, false); }
    private:
        form(const ::std::string& n, form* p)
            : m_name(n)
            , m_parent(p)
            , m_container()
        {}
    public:
        form(const ::std::string& n)
            : form(n, nullptr)
        {}
 
        form(const form& rhs)
            : m_name(rhs.m_name)
            , m_parent(rhs.m_parent)
            , m_container(rhs.m_container)
        {}
        form& operator=(const form& rhs)
        {
            m_name      = rhs.m_name;
            m_parent    = rhs.m_parent;
            m_container = rhs.m_container;
            return *this;
        }
 
        form& add(const ::std::string& name)
        {
            auto obj = std::make_shared<form>(name);
            obj->m_parent = this;
            m_container.emplace_back(obj);
            return *obj;
        }
 
        form& done()
        {
            if(m_parent)
                return *m_parent;
            return *this;
        }
 
        form& front()
        {
            assert(!m_container.empty());
            return *m_container.front();
        }
 
        const ::std::string& get_name()const
            { return m_name; }
 
        bool operator==(const form& rhs)const
            { return m_name == rhs.m_name; }
        bool operator!=(const form& rhs)const
            { return !this->operator ==(rhs); }
        
        
        const container& get_children() const
            { return m_container; }
        
    private:
        ::std::string  m_name;
        form*          m_parent;
        container      m_container;
    };
 
void view(const form& widget, const size_t depth = 0 )
{
    std::cout << std::string(depth, ' ') 
        << widget.get_name()
        << '\n';
 
    const auto& children = widget.get_children();
    for(const auto& pChild: children)
        view(*pChild, depth + 1);
}
 
int main()
{
 
   // --- наполняем наше деревце дочерними элементами
 
    auto widget = form("root")
        .add("==1==")
            .add("==1.1==").done()
            .add("==1.2==").done()
            .add("==1.3==").done()        
        .done()
        .add("==2==")
            .add("==2.1==").done()
            .add("==2.2==")
                .add("==2.2.1==").done()
                .add("==2.2.2==").done()
                .add("==2.2.3==").done()
            .done()
            .add("==2.3==").done()        
        .done()
    .done();    
    
   // показываем
    view(widget);
    
    std::cout << "\n";
    
    // --- рекурсивно бежим по элементам контейнера
    for(auto&& element: widget)
        std::cout << element.get_name() << '\n';
    
    std::cout << "\n";
    
    // --- итератор заказывали?
    form::iterator i = widget.begin();
    form::iterator e = widget.end();
    while( i != e )
        std::cout << i->get_name() << '\n',
        ++i;
 
}