Основы C++: Ошибка перегрузки оператора шаблона — «ошибка вывода/подстановки аргумента шаблона»

Не следует перегружать operator- в глобальном пространстве имен.

#include <cstddef>
#include <memory>

template <typename T>
struct MyVector {
  struct iterator {
    T* ptr;
    ptrdiff_t operator-(const iterator& b) const { return ptr - b.ptr; }
  };

  std::unique_ptr<T[]> data;
  size_t size = 0;

  MyVector() = default;
  MyVector(size_t sz) : size(sz) { data = std::make_unique<T[]>(size); }
  iterator begin() const { return {data.get()}; }
  iterator end() const { return {data.get() + size}; }
};

int main() {
  MyVector<int> mv(3);
  mv.end() - mv.begin();  // fails
}

См. Вывод аргументов шаблона. T в typename MyVector<T>::iterator не подлежит вычету, iterator является зависимым типом.

Я не могу объяснить правила вывода шаблона, возможно, вывод происходит только для объекта, переданного в качестве аргумента, а не для типа вложенности. Один из способов решения этой проблемы (и тот, который используется, например, в стандартной библиотеке gcc) — создать iterator невложенный класс, предоставляя его только как псевдоним вложенного имени (см. в Интернете):

namespace detail {
template <typename T>
struct MyIterator {
    T* ptr;
    MyIterator(T* p) : ptr(p) {}
};

template <typename T>
int operator-(MyIterator<T> a, MyIterator<T> b) {
    return a.ptr - b.ptr;
}
}  // namespace detail

template <typename T>
struct MyVector {
    using iterator = detail::MyIterator<T>;
    // ... rest of implementation
};

int main() {
    MyVector<int> mv(3);
    mv.end() - mv.begin();  // fails
}

Лучше ли это, чем просто сделать это функцией-членом, я бы сказал, это спорно.
Плюсы заключаются в том, что он следует рекомендациям основных правил и идиом перегрузки операторов, которые являются хорошо известной вики по C++, и люди склонны придерживаться этого (хотя он также специально допускает случай создания такого члена оператора во вложенных сорт). Это также позволяет вам повторно использовать этот тип итератора в других контейнерах (например, в std::array-подобном контейнере).
Обратной стороной является то, что вы теряете возможность сделать это по-настоящему private, и люди в любом случае будут иметь доступ к detail::MyIterator.

во-первых, я уже делал это раньше, и в любом случае я бы рекомендовал использовать класс вместо структуры, если вы хотите, чтобы оператор - работал с MyVector.end() - MyVector.begin(), он должен находиться в структуре итератора, и в этом случае оператор должен иметь 1 аргумент - цель. Ошибка в основном возникла из-за того, что компилятор не смог разрешить шаблон, потому что вы поместили его над функцией-оператором, а это означало, что он ожидал тип при вызове функции. Я не изменял какой-либо ваш код, кроме того, что требовалось. чтобы это заработало, поскольку вы сказали, что это проект, который нужно изучить, вот исправленный и работающий код:

#include <iostream>
#include <memory>

template <typename T>
struct MyVector {
    struct iterator {
        T* ptr;
        iterator(T* p) : ptr(p) {}

        int operator - (const iterator tgt) const {
            return this->ptr - tgt.ptr;
        }
    };

    std::unique_ptr<T[]> data;
    size_t size;

    MyVector() : data(nullptr), size(0) {}
    MyVector(size_t sz) : size(sz) {
        data = std::make_unique<T[]>(size);
    }

    iterator begin() {
        return iterator(data.get());
    }

    iterator end() {
        return iterator(data.get() + size);
    }
};

int main() {
    MyVector<int> mv(3);
    int thing = mv.end() - mv.begin();
    std::cout << thing << std::endl;
}