Перегрузка операторов в абстрактном классе

Пытаюсь создать абстрактный класс Iterator. Его наследники - классы Array_Iterator и List_Iterator. В этих классах переопределены операторы *, ++, --, ==, !=, -.

   template <typename T>
class Array_Iterator : public Iterator<T> {
    friend class Vector<T>;

protected:
    Vector<T>* m_array;
    T* m_ptr;

public:
    Array_Iterator() : m_array(nullptr), m_ptr(nullptr) {};

    Array_Iterator(Vector<T>* array, T* ptr) : m_array(array), m_ptr(ptr) {};

    T& operator*() override {
        if (*this == m_array->end())
            throw std::runtime_error("\n(Array_Iterator) operator *: index out of range\n");
        return *m_ptr;
    }

    Array_Iterator& operator++() override {
        if (*this == m_array->end())
            throw std::runtime_error("\n(Array_Iterator) operator ++: index out of range\n");
        ++m_ptr;
        return *this;
    }

    Array_Iterator& operator--() override{
        if (*this == m_array->begin())
            throw std::runtime_error("\n(Array_Iterator) operator --: index out of range\n");
        --m_ptr;
        return *this;
    }

    friend bool operator== (const Array_Iterator &it1, const Array_Iterator &it2) { return it1.m_ptr == it2.m_ptr; }
    friend bool operator!= (const Array_Iterator &it1, const Array_Iterator &it2) { return it1.m_ptr != it2.m_ptr; }

    friend int operator- (const Array_Iterator &it1, const Array_Iterator &it2) { return it1.m_ptr - it2.m_ptr; }
};

Класс List_Iterator выглядит аналогично Array_Iterator.

template <typename T>
class Iterator {
public:
    virtual T& operator*() = 0;
    virtual Iterator<T>& operator++() = 0;
    virtual Iterator<T>& operator--() = 0;

    friend bool operator== (const Iterator<T>& it1, const Iterator<T>& it2) { return it1 == it2; }
    friend bool operator!= (const Iterator<T>& it1, const Iterator<T>& it2) { return it1 != it2; }
    friend bool operator- (const Iterator<T>& it1, const Iterator<T>& it2) { return it1 - it2; }

};

Сложности возникли с операторами ==, != и -, так как они перегружены через дружественные функции. Если сделать так как у меня сейчас, при попытке написать следующее

template <typename T>
void test(Iterator<T>& b, Iterator<T>& e) {
    std::cout << (e == b);
}

возникает ошибка "operator==: рекурсия на всех путях выполнения, функция вызовет переполнение стека", и это понятно почему - операторы ==, != и - просто вызывают сами себя. Но как сделать правильно - не могу понять. Есть только идея переделать перегрузку операторов не через дружественные функции. Но есть ли какой-то способ оставить такую реализацию? Подскажите пожалуйста что-нибудь по этому вопросу.