Что должен возвращать бинарный минус у итератора?

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
 
using namespace std;
 
template<typename T>
class MyQueue{
 
    private:
 
        // Узел очереди (состоит из значения и указателя на след. элемент очереди)
        class Node{
            public:
                T value;  // Значение узла
                Node* next = nullptr;  // Указатель на след. элемент
                Node(T value): value(value){}
        };
 
        Node* first = nullptr;  // Указатель на начало очереди
        Node* last = nullptr;  // Указатель на конец очереди
        int elems = 0; // Кол-во элементов
 
    public:
 
        // Итератор очереди
        class Iterator{
            private:
                Node* pointer;  // Указатель на узел
            
            public:
                Iterator(Node* pointer): pointer(pointer){}
 
                // Перегрузка постфиксного инкремента (с фиктивным параметром)
                void operator++(int){
                    if(this->pointer != nullptr){
                        this->pointer = this->pointer->next;
                    }
                }
 
                // Перегрузка префиксного инкремента
                void operator++(){
                    (*this)++;
                }
 
                // Перегрузка оператора разыменования
                T operator*(){
                    if(this->pointer != nullptr){
                        return this->pointer->value;
                    }else{
                        return T(0);
                    }
                }
 
                // Перегрузка оператора равенства
                bool operator==(const Iterator& b){
                    return this->pointer == b.pointer;
                }
 
                // Перегрузка оператора неравенства
                bool operator!=(const Iterator& b){
                    return this->pointer != b.pointer;
                }
 
                // Iterator& operator-(const Iterator& b){
                //     Node* res_node = new Node(this->pointer->value - b.pointer->value);
                //     return *(new Iterator(res_node));
                // }
 
                // Метод получения указателя на следующий элемент
                Node* getNext(){
                    return this->pointer->next;
                }
        };
 
        
 
        // Конструктор списка инициализации
        MyQueue(initializer_list<T> init){
            for(auto el : init)
                this->push(el);
        }
 
        // Добавление элемента в конец
        void push(T value){
 
            Node* node = new Node(value);
            
            if(this->first == nullptr){
                this->first = node;
            }
            if(this->last == nullptr){
                this->last = node;
            }else{
                this->last->next = node;
                this->last = node;
            }
 
            this->elems++;
        }
 
        // Взятие элемента из начала
        T pop(){
            
            
            if(this->first != nullptr){
 
                this->elems--;
 
                T val = this->first->value;
 
                if(this->first == this->last){
                    
                    delete this->first;
 
                    this->first = nullptr;
                    this->last = nullptr;
                }else{
 
                    Node* tmp_node = this->first->next;
 
                    delete this->first;
                    this->first = tmp_node;
                }
 
                return val;
            }else{
                return T(0);
            }
        }
 
        // Метод возврата итератора на начало
        Iterator& begin(){
            return *(new Iterator(this->first));
        }
        
        // Метод возврата итератора на конец
        Iterator& end(){
            return *(new Iterator(nullptr));
        }
 
        // Метод подсчета кол-ва элементов
        int size(){
            return this->elems;
        }
 
        // Метод проверки на пустоту
        bool empty(){
            return this->first ? false : true;
        }
 
};