Bad variant of iterators in C++

#include <list>
#include <vector>

template<class T>
class VectorList
{
    using VectT = std::vector<T>;
    using ListT = std::list<VectT>;

    ListT data_;

public:
    template<typename TypeValue> class Iterator;
    template<typename TypeValue> class ConstIterator;

    using value_type = T;
    using iterator = Iterator<value_type>;
    using const_iterator = ConstIterator<value_type>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;

    VectorList() = default;
    VectorList(VectorList const&) = default;
    VectorList(VectorList &&) = default;

    VectorList & operator=(VectorList &&)     = default;
    VectorList & operator=(VectorList const&) = default;

    // метод, который будет использоваться для заполнения VectorList
    // гарантирует, что в списке не будет пустых массивов
    template<class It>
    void append(It p, It q);

    bool empty() const { return size() == 0; }

    // определите метод size
    size_t size() const
    {
        size_t size = 0;
        for (VectT const& vec : data_) {
            size += vec.size();
        }
        return size;
    }

    // определите const_iterator
    iterator begin() { return iterator(&data_, 0); }
    iterator end()   { return iterator(&data_);    }

    const_iterator cbegin() { return const_iterator(&data_, 0); }
    const_iterator cend()   { return const_iterator(&data_);    }

    const_reverse_iterator rbegin() { return const_reverse_iterator(cend());   }
    const_reverse_iterator rend()   { return const_reverse_iterator(cbegin()); }

    template<typename TypeValue>
    class Iterator : public std::iterator<std::bidirectional_iterator_tag, TypeValue> {
        friend class VectorList;
        friend class Iterator;

            ListT * data_;
            typename ListT::iterator list_;
            typename VectT::iterator vec_;

            Iterator(ListT * data) : data_(data)
            {
                if (data->begin() == data->end()) {
                    list_ = data->begin();
                    vec_ =  typename VectT::iterator();
                } else {
                    list_ = std::prev(data->end());
                    vec_  = (*list_).end();
                }
            }

            Iterator(ListT * data, size_t n) : data_(data)
            {
                if (data->begin() == data->end()) {
                    list_ = data->begin();
                    vec_  = typename VectT::iterator();
                } else {
                    list_ = data->begin();
                    vec_  = (*list_).begin();
                }
            }

        public:
            Iterator() = default;
            Iterator(Iterator const& other)
                : data_(other.data_), list_(other.list_), vec_(other.vec_) {}

            bool operator==(Iterator const& other) const
            {
                return list_ == other.list_ && vec_ == other.vec_;
            }

            bool operator!=(Iterator const& other) const
            {
                return !(*this == other);
            }

            typename Iterator::reference operator*()  { return *vec_;    }
            typename Iterator::pointer   operator->() { return &(*vec_); }

            Iterator& operator++()
            {
                if (++vec_ == (*list_).end())
                    if (list_ != std::prev(data_->end()))
                        vec_ = (*(++list_)).begin();
                return *this;
            }

            Iterator operator++(int)
            {
                Iterator prev(*this);
                ++(*this);
                return prev;
            }

            Iterator& operator--()
            {
                if (--vec_ == std::prev((*list_).begin()))
                    if (list_ != data_->begin())
                        vec_ = std::prev((*(--list_)).end());
                return *this;
            }

            Iterator operator--(int)
            {
                Iterator prev(*this);
                --(*this);
                return prev;
            }
    };

    template<typename TypeValue>
    class ConstIterator : public std::iterator<std::bidirectional_iterator_tag, const TypeValue> {
        friend class VectorList;

            ListT * data_;
            typename ListT::iterator list_;
            typename VectT::iterator vec_;

            ConstIterator(ListT * data) : data_(data)
            {
                if (data->begin() == data->end()) {
                    list_ = data->begin();
                    vec_ =  typename VectT::iterator();
                } else {
                    list_ = std::prev(data->end());
                    vec_  = (*list_).end();
                }
            }

            ConstIterator(ListT * data, size_t n) : data_(data)
            {
                if (data->begin() == data->end()) {
                    list_ = data->begin();
                    vec_  = typename VectT::iterator();
                } else {
                    list_ = data->begin();
                    vec_  = (*list_).begin();
                }
            }

        public:
            ConstIterator() = default;
            ConstIterator(ConstIterator const& other)
                : data_(other.data_), list_(other.list_), vec_(other.vec_) {}
            ConstIterator(Iterator<TypeValue> const& other)
                : data_(other.data_), list_(other.list_), vec_(other.vec_) {}

            bool operator==(ConstIterator const& other) const
            {
                return list_ == other.list_ && vec_ == other.vec_;
            }

            bool operator!=(ConstIterator const& other) const
            {
                return !(*this == other);
            }

            typename ConstIterator::reference operator*()  const { return *vec_;    }
            typename ConstIterator::pointer   operator->() const { return &(*vec_); }

            ConstIterator& operator++()
            {
                if (++vec_ == (*list_).end())
                    if (list_ != std::prev(data_->end()))
                        vec_ = (*(++list_)).begin();
                return *this;
            }

            ConstIterator operator++(int)
            {
                ConstIterator prev(*this);
                ++(*this);
                return prev;
            }

            ConstIterator& operator--()
            {
                if (--vec_ == std::prev((*list_).begin()))
                    if (list_ != data_->begin())
                        vec_ = std::prev((*(--list_)).end());
                return *this;
            }

            ConstIterator operator--(int)
            {
                ConstIterator prev(*this);
                --(*this);
                return prev;
            }
    };
};