В чем преимущества std::distance перед вычитанием итераторов в C++?

Главное преимущество: универсальность и работа с разными типами итераторов

Основное различие между вычитанием итераторов и std::distance кроется в категориях итераторов. В C++ итераторы делятся на несколько категорий: однонаправленные (forward), двунаправленные (bidirectional) и итераторы произвольного доступа (random access). Оператор вычитания (operator-) поддерживается только итераторами произвольного доступа (как у std::vector, std::deque, std::array, C-массивов). Для всех остальных контейнеров (списки, множества, словари) вычитание итераторов вызовет ошибку компиляции.

#include <vector>
#include <list>
#include <iterator>
#include <iostream>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    auto it1 = lst.begin();
    auto it2 = lst.end();

    // Ошибка компиляции!
    // auto diff = it2 - it1; 

    // А это работает для любого контейнера:
    auto dist = std::distance(it1, it2);
    std::cout << dist; // Выведет 5
}

std::distance — это умная функция, которая использует технику диспетчеризации по категории итератора. Для итераторов произвольного доступа она просто вызывает last - first (константная сложность O(1)). Для всех остальных типов она выполняет последовательный обход от first до last с помощью оператора ++ (линейная сложность O(N)). Таким образом, вы получаете оптимальную производительность в любом случае, не думая о типе контейнера.

Безопасность и читаемость кода

Использование std::distance делает код более:

• Обобщенным (generic): вы можете написать шаблонную функцию, которая будет работать с любым контейнером, поддерживающим итераторы.
• Интуитивно понятным: название std::distance явно говорит о намерении программиста — вычислить расстояние. Вычитание итераторов можно спутать с арифметикой указателей.
• Безопасным при рефакторинге: если вы замените std::vector на std::list, код с вычитанием сломается, а код с std::distance продолжит работать (хотя может стать медленнее — и это будет явно видно из сигнатуры).

Пример: шаблонная функция поиска

#include <vector>
#include <list>
#include <iterator>
#include <iostream>

// Шаблонная функция, работающая с любым контейнером
template <typename Iterator>
ptrdiff_t find_position(Iterator first, Iterator last, const typename std::iterator_traits<Iterator>::value_type& value) {
    auto it = std::find(first, last, value);
    if (it == last) return -1;
    return std::distance(first, it); // Работает всегда!
}

int main() {
    std::vector<int> vec = {10, 20, 30, 40};
    std::list<int> lst = {10, 20, 30, 40};

    std::cout << find_position(vec.begin(), vec.end(), 30) << "\n"; // 2
    std::cout << find_position(lst.begin(), lst.end(), 30) << "\n"; // 2
}

Когда вычитание все же лучше?

Если вы точно знаете, что работаете только с контейнерами произвольного доступа (вектор, дек, массив) и никогда не будете менять их тип, то вычитание может быть чуть более эффективным (избегает вызова функции) и более лаконичным. Но в современном C++ компиляторы часто инлайнят std::distance для random-access итераторов, так что разницы в производительности практически нет.

Итог: Используйте std::distance как правило по умолчанию. Это делает код гибким, безопасным и самодокументируемым. Вычитание оставьте для низкоуровневых операций с указателями или в узких местах, где каждая микросекунда на счету и тип контейнера гарантирован.

// Пример, где вычитание уместно:
int arr[] = {1, 2, 3, 4, 5};
int* begin = arr;
int* end = arr + 5;
ptrdiff_t size = end - begin; // Очевидно и эффективно