Использование вложенного класса

template<typename Item>
class MyArrayList
{
    Item * items_;
    int size_;
    int capacity_;
    void GrowArray();
public:
    class iterator
    {
        const MyArrayList<Item> * ptr_;
        int index_;
        iterator(const MyArrayList<Item> * ptr, int index)
            : ptr_(ptr), index_(index) {}
        friend iterator MyArrayList<Item>::begin() const;
        friend iterator MyArrayList<Item>::end() const;
        friend iterator MyArrayList<Item>::rbegin() const;
        friend iterator MyArrayList<Item>::rend() const;
    public:
        iterator()
            : ptr_(nullptr), index_(-1) {}
        void operator++() 
        { ptr_ != nullptr && index_ < ptr_->size_ ? ++index_ : throw std::logic_error("iterator not incrementable"); }
        void operator++(int)
        { operator++(); }
        void operator--() 
        { ptr_ != nullptr && index_ > 0  ? --index_ : throw std::logic_error("iterator not decrementable"); }
        void operator--(int)
        { operator--(); }
        iterator & operator+(const int val);
        iterator & operator-(const int val);
        friend iterator & operator+(const int val, const iterator & iter);
        bool operator==(const iterator & other) const;
        bool operator!=(const iterator & other) const
        { return !operator==(other); }
        Item & operator*() const;
    };
    explicit MyArrayList(const int lenght = 0);
    MyArrayList(const MyArrayList<Item> & other);
    MyArrayList<Item> & operator=(const MyArrayList<Item> & other);
    ~MyArrayList() { delete[] items_; }
    void reserve(const int size);
    Item & at(const int index) const;
    int indexOf(const Item & item) const;
    void insert(const int index, const Item & item);
    void removeAt(const int index);
    void push_back(const Item & item);
    void pop_back();
    void clear();
    void copyTo(Item arr[], int arrIndex) const;
    void swap(MyArrayList<Item> & other);
    bool remove(const Item & item);
    bool contains(const Item & item) const;
    int size() const { return size_; }
    int capacity() const { return capacity_; }
    bool empty() const { return size_ == 0; }
    Item & operator[](const int index) const;
    iterator begin() const { return iterator::iterator(this, 0);  }
    iterator rbegin() const { return iterator(this, size_ - 1); }
    iterator end() const { return iterator(this, size_); }
    iterator rend() const { return iterator(this, -1); }
};

template<typename Item>
iterator & MyArrayList<Item>::iterator::operator+(const int val)
{
    // TODO: insert return statement here
}

class iterator;

auto MyArrayList<Item>::iterator::operator-(const int val)->decltype(*this)
{
    
    return *this;
}

template<typename Item>
MyArrayList<Item>::iterator & MyArrayList<Item>::iterator::operator+(const int val)
{
    // TODO: insert return statement here
}

template<typename Item>
typename MyArrayList<Item>::iterator & MyArrayList<Item>::iterator::operator+(const int val)
{
    // TODO: insert return statement here
}

template<typename Item>
auto MyArrayList<Item>::iterator::operator+(const int val)   //<--- убрал ссылку
{
    // TODO: insert return statement here
}

template<typename Item>
typename MyArrayList<Item>::iterator MyArrayList<Item>::iterator::operator+(const int val)
{
    // TODO: insert return statement here
}

template<typename Item>
auto MyArrayList<Item>::iterator::operator+(const int val) -> iterator
{
  ...
}

using Item = int;
 
template <typename T>
class MyArrayList
{
public:
    static int iterator;
};
 
template <>
int MyArrayList<Item>::iterator = 1;
 
int main()
{
    std::cout << MyArrayList<Item>::iterator;
}

struct A { 
  int i; 
 
  void foo() {
    A::i = 5; // <- вот он!
  }
 
  int A::*p = &A::i; // <- вот он снова!
};

template<typename Item>
auto MyArrayList<Item>::iterator::operator+(const int val) -> iterator

template<typename Item>
class MyArrayList
{
    //...
        public:
    class iterator
    {
        //...
    public:
        //...
        iterator operator+(const int val) const;
        iterator operator-(const int val) const;
        friend iterator operator+(const int val, const iterator & iter)
        { return iter + val; }
        //...
    };
    //...
};