C++ std::distance原理、性能优化与实战避坑指南

// 伪代码示意：针对随机访问迭代器的特化版本
template <class RandomAccessIterator>
typename std::iterator_traits<RandomAccessIterator>::difference_type
distance(RandomAccessIterator first, RandomAccessIterator last) {
    return last - first; // 直接相减，一步到位
}

// 伪代码示意：针对输入/前向/双向迭代器的通用版本
template <class InputIterator>
typename std::iterator_traits<InputIterator>::difference_type
distance(InputIterator first, InputIterator last) {
    typename std::iterator_traits<InputIterator>::difference_type n = 0;
    while (first != last) {
        ++first;
        ++n;
    }
    return n;
}

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

int main() {
    // 示例1：随机访问迭代器 (std::vector) - O(1)
    std::vector<int> vec = {10, 20, 30, 40, 50};
    auto vec_start = vec.begin() + 1; // 指向20
    auto vec_end = vec.end() - 1;     // 指向50（最后一个元素）
    auto dist_vec = std::distance(vec_start, vec_end);
    std::cout << "Vector distance: " << dist_vec << std::endl; // 输出：3 (元素20, 30, 40)

    // 示例2：双向迭代器 (std::list) - O(n)
    std::list<int> my_list = {1, 2, 3, 4, 5};
    auto list_start = std::next(my_list.begin(), 2); // 指向3
    auto dist_list = std::distance(list_start, my_list.end());
    std::cout << "List distance: " << dist_list << std::endl; // 输出：3 (元素3, 4, 5)

    return 0;
}

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<std::string> fruits = {"apple", "banana", "cherry", "date"};
    auto it = std::find(fruits.begin(), fruits.end(), "cherry");

    if (it != fruits.end()) {
        // 使用 std::distance 计算迭代器与起始迭代器的距离，即索引
        auto index = std::distance(fruits.begin(), it);
        std::cout << "'cherry' found at index: " << index << std::endl; // 输出：2
        // 对于vector，你也可以直接用 it - fruits.begin()，但 distance 更通用。
    }
    return 0;
}

#include <iostream>
#include <list>
#include <algorithm>
#include <iterator>

int main() {
    std::list<int> numbers = {1, 4, 7, 2, 9, 3, 6};
    // 找到第一个大于5的元素
    auto first_gt5 = std::find_if(numbers.begin(), numbers.end(),
                                   [](int n){ return n > 5; });
    // 找到最后一个小于等于8的元素（从后往前找更高效，这里演示distance）
    // 注意：对于list，我们无法直接跳转，需要遍历。
    // 一种方法是使用 std::find_if 配合反向迭代器，但计算距离时需小心迭代器类别转换。
    // 更清晰的做法：定义一个区间，用 distance 计算这个区间的大小。
    auto start = numbers.begin();
    auto end = numbers.end();
    // 手动“划分”区间：从 start 到 first_gt5 是小于等于5的部分？
    // 不，让我们换一个例子：计算整个列表中大于3的元素个数。
    // 我们可以用 partition 或 stable_partition 把大于3的挪到前面，然后计算距离。
    // 但这会修改原列表。一个不修改的方法是使用 count_if。
    // 为了演示 distance，我们使用 std::partition_point（需要先排序，不适用此例）。
    // 更合适的例子：使用 std::upper_bound 在已排序序列中找分界点。
    std::list<int> sorted_nums = {1, 2, 3, 5, 7, 9};
    // 找到第一个大于5的元素的位置
    auto bound = std::upper_bound(sorted_nums.begin(), sorted_nums.end(), 5);
    auto count_greater_than_5 = std::distance(bound, sorted_nums.end());
    std::cout << "Numbers greater than 5: " << count_greater_than_5 << std::endl; // 输出：2 (7, 9)
    return 0;
}

template<typename T>
class SimpleForwardList {
    struct Node { T data; Node* next; };
    Node* head = nullptr;
public:
    class Iterator { /* 实现前向迭代器操作符 */ };

    Iterator begin() { return Iterator(head); }
    Iterator end() { return Iterator(nullptr); }

    // 使用 std::distance 计算大小，时间复杂度 O(n)
    size_t size() const {
        // 注意：需要 const_cast 来获取非const的迭代器用于遍历，或者实现const版本的begin/end。
        // 这里为简化，假设我们有 const begin/end。
        return static_cast<size_t>(std::distance(begin(), end()));
    }
};

// 错误示例1：迭代器指向不同容器
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};
auto dist = std::distance(v1.begin(), v2.begin()); // 未定义行为！

// 错误示例2：对于list，last 在 first 之前（且非随机访问）
std::list<int> lst = {1, 2, 3};
auto it1 = std::next(lst.begin(), 2); // 指向3
auto it2 = lst.begin();               // 指向1
auto dist = std::distance(it1, it2);  // 未定义行为！可能死循环。
// 正确的做法是调换顺序：std::distance(it2, it1) 得到 2。

template <typename Iterator>
void process_range(Iterator first, Iterator last) {
    // 使用 distance 获取区间长度，无论Iterator是什么类型
    auto length = std::distance(first, last);
    std::cout << "Processing " << length << " elements." << std::endl;
    // ... 其他处理逻辑
}

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

template <typename Iterator>
void smart_process(Iterator first, Iterator last) {
    using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;

    // 方法1：使用类型标签分发 (C++98/11/14/17)
    if constexpr (std::is_same_v<iterator_category, std::random_access_iterator_tag>) {
        std::cout << "Random access iterator detected. Fast path.\n";
        // 可以安全地使用 first + n 等操作
        auto mid = first + std::distance(first, last) / 2; // 对于随机访问迭代器，这个加法是O(1)
    } else {
        std::cout << "Non-random access iterator. Using generic path.\n";
        auto mid = first;
        std::advance(mid, std::distance(first, last) / 2); // 对于非随机访问，advance是O(n)
    }

    // 方法2：C++20 使用概念更简洁
    // if constexpr (std::random_access_iterator<Iterator>) { ... }
}