如何在C++范围for循环中使用并行迭代器遍历两个容器？

如果你想在C++里实现类似Python zip的并行遍历效果，把两个容器的元素配对到范围for循环中，有以下几种可行方案：

方案1：C++20 标准库自带的std::views::zip #

C++20引入的范围库直接提供了std::views::zip，可以把多个容器打包成一个可遍历的视图，完美适配范围for循环：

#include <vector>
#include <ranges>

class Result {
    // 你的类定义
};

int main() {
    std::vector<Result> results;
    std::vector<Result> groundTruth(2);

    // 打包两个容器，同时遍历对应元素
    for (auto&& [r, gt] : std::views::zip(results, groundTruth)) {
        // 直接使用r和gt进行比较逻辑
        // compare r and gt
    }
}

• 要求编译器支持C++20及以上版本（如GCC 10+、Clang 12+、MSVC 2019+）。
• std::views::zip会自动遍历到最短容器的末尾，避免越界访问。

方案2：手动实现简易zip迭代器（兼容C++11+） #

如果项目还无法升级到C++20，可以自己写一个轻量的zip包装器，让它支持范围for：

#include <vector>
#include <utility>

// 自定义zip迭代器，封装两个迭代器的并行移动
template <typename Iter1, typename Iter2>
class ZipIterator {
public:
    using value_type = std::pair<typename Iter1::value_type&, typename Iter2::value_type&>;

    ZipIterator(Iter1 it1, Iter2 it2) : it1_(it1), it2_(it2) {}

    value_type operator*() {
        return {*it1_, *it2_};
    }

    ZipIterator& operator++() {
        ++it1_;
        ++it2_;
        return *this;
    }

    bool operator!=(const ZipIterator& other) const {
        // 以先到达末尾的容器为准结束遍历
        return it1_ != other.it1_ && it2_ != other.it2_;
    }

private:
    Iter1 it1_;
    Iter2 it2_;
};

// 包装容器的zip范围对象
template <typename Cont1, typename Cont2>
class ZipRange {
public:
    ZipRange(Cont1& cont1, Cont2& cont2) : cont1_(cont1), cont2_(cont2) {}

    ZipIterator<typename Cont1::iterator, typename Cont2::iterator> begin() {
        return {cont1_.begin(), cont2_.begin()};
    }

    ZipIterator<typename Cont1::iterator, typename Cont2::iterator> end() {
        return {cont1_.end(), cont2_.end()};
    }

private:
    Cont1& cont1_;
    Cont2& cont2_;
};

// 辅助函数，简化zip调用
template <typename Cont1, typename Cont2>
ZipRange<Cont1, Cont2> zip(Cont1& cont1, Cont2& cont2) {
    return {cont1, cont2};
}

// 使用示例
class Result {
    // 你的类定义
};

int main() {
    std::vector<Result> results;
    std::vector<Result> groundTruth(2);

    for (auto&& pair : zip(results, groundTruth)) {
        auto& r = pair.first;
        auto& gt = pair.second;
        // compare r and gt
    }
}

• 这个实现兼容C++11及以上版本。
• 如果需要处理const容器，可以添加对应的const迭代器重载；若要求两个容器长度严格一致，可修改operator!=的判断逻辑为it1_ != other.it1_（前提是确保容器长度相同）。

方案3：传统迭代器循环（无额外依赖） #

如果不想折腾新特性或自定义代码，直接用普通迭代器循环也能实现并行遍历，兼容性拉满：

#include <vector>

class Result {
    // 你的类定义
};

int main() {
    std::vector<Result> results;
    std::vector<Result> groundTruth(2);

    auto res_it = results.begin();
    auto gt_it = groundTruth.begin();
    // 同时遍历两个迭代器，直到其中一个到达末尾
    for (; res_it != results.end() && gt_it != groundTruth.end(); ++res_it, ++gt_it) {
        auto& r = *res_it;
        auto& gt = *gt_it;
        // compare r and gt
    }
}

内容的提问来源于stack exchange，提问作者Nitron_707