Пользовательские Итераторы

Я попытался реализовать итераторы для своего класса и неожиданно получил следующее:

предупреждение: ISO C ++ говорит, что они неоднозначны, хотя худшее преобразование для первого лучше, чем худшее преобразование для второго

кандидат 1: ‘Итератор Итератор :: оператор + (const ptrdiff_t&) [с T = int; ptrdiff_t = long long int] ‘

кандидат 2: «оператор + (int, без знака int)»

Вот Iterator код:

template<typename T>
class Iterator {

public:

Iterator(T *p = nullptr) { this->ptr = p; }
Iterator(const Iterator<T>& iter) = default;

Iterator<T>& operator=(const Iterator<T>& iter) = default;
Iterator<T>& operator=(T* p) { this->ptr = p; return *this; }

operator bool() const { return this->ptr ? true : false; }

bool operator==(const Iterator<T>& p) const { return this->ptr == p.getConstPtr(); }
bool operator!=(const Iterator<T>& p) const { return this->ptr != p.getConstPtr(); }

Iterator<T>& operator+=(const ptrdiff_t& v) { this->ptr += v; return *this; }
Iterator<T>& operator-=(const ptrdiff_t& v) { this->ptr -= v; return *this; }
Iterator<T>& operator++() { ++this->ptr; return *this; }
Iterator<T>& operator--() { --this->ptr; return *this; }
Iterator<T> operator++(int) { auto temp(*this); ++this->ptr; return temp; }
Iterator<T> operator--(int) { auto temp(*this); --this->ptr; return temp; }
Iterator<T> operator+(const ptrdiff_t& v) { auto oldPtr = this->ptr; this->ptr += v; auto temp(*this); this->ptr = oldPtr; return temp; }
Iterator<T> operator-(const ptrdiff_t& v) { auto oldPtr = this->ptr; this->ptr -= v; auto temp(*this); this->ptr = oldPtr; return temp; }

ptrdiff_t operator-(const Iterator<T>& p) { return std::distance(p.getPtr(), this->getPtr()); }

T& operator*() { return *(this->ptr); }
const T& operator*() const { return *(this->ptr); }
T* operator->() { return this->ptr; }

T* getPtr() const { return this->ptr; }
const T* getConstPtr() const { return this->ptr; }

private:

T *ptr;

};

И вот как я typedef это внутри моего класса:

template<typename T>
class ExampleClass {

public:

// ...

typedef Iterator<T>       iterator;
typedef Iterator<const T> const_iterator;

// ...

iterator begin() { return iterator(&this->ptr()[0]); }
iterator end() { return iterator(&this->ptr()[this->size()]); }
const_iterator cbegin() { return const_iterator(&this->ptr()[0]); }
const_iterator cend() { return const_iterator(&this->ptr()[this->size()]); }

// ...

// A function where I use the operator+
void slice(unsigned int first, unsigned int last) {
// ...
auto it = this->begin() + first; // <--------
// ...
}

};

Может быть, я что-то упустил, но как (Iterator, ptrdiff_t) а также (int, unsigned int) неоднозначны?