如何构造步进n的迭代器以用std::transform处理每隔n个元素？

核心结论 #

不需要完全自行实现，可结合标准库工具完成需求，但要区分串行与并行场景的实现方式，尤其是支持std::execution::par_unseq的并行场景有严格限制。

具体实现方案 #

1. 串行场景：自定义迭代器适配器或直接遍历 #

如果不需要并行执行，你可以封装一个迭代器适配器，重载operator++()时调用std::advance完成步进。比如基于标准迭代器的简单封装：

template <typename Iter>
struct StepIterator {
    using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
    using value_type = typename std::iterator_traits<Iter>::value_type;
    using difference_type = typename std::iterator_traits<Iter>::difference_type;
    using pointer = typename std::iterator_traits<Iter>::pointer;
    using reference = typename std::iterator_traits<Iter>::reference;

    StepIterator(Iter it, difference_type step) : it_(it), step_(step) {}

    reference operator*() const { return *it_; }
    pointer operator->() const { return &(*it_); }

    StepIterator& operator++() {
        std::advance(it_, step_);
        return *this;
    }

    StepIterator operator++(int) {
        StepIterator tmp = *this;
        std::advance(it_, step_);
        return tmp;
    }

    bool operator==(const StepIterator& other) const { return it_ == other.it_; }
    bool operator!=(const StepIterator& other) const { return !(*this == other); }

private:
    Iter it_;
    difference_type step_;
};

// 辅助函数用于创建适配器
template <typename Iter>
StepIterator<Iter> make_step_iterator(Iter it, typename std::iterator_traits<Iter>::difference_type step) {
    return StepIterator<Iter>(it, step);
}

使用时直接把这个适配器传入std::transform即可，只对每隔n个的元素执行转换。当然你也可以跳过适配器，直接写一个遍历函数完成相同逻辑，代码会更简洁。

2. 并行场景（支持std::execution::par_unseq）：避免自定义迭代器 #

并行执行策略std::execution::par_unseq要求迭代器必须是LegacyRandomAccessIterator，且严格符合标准库的迭代器概念。自定义的步进迭代器适配器几乎无法满足这些要求——并行算法可能会直接操作迭代器的底层偏移或指针，自定义适配器的行为会导致未定义行为。

更稳妥的方式是利用连续容器的索引特性，直接在std::transform的lambda中判断元素是否需要转换：

#include <algorithm>
#include <execution>
#include <vector>

int main() {
    std::vector<int> src = {1,2,3,4,5,6,7,8,9};
    std::vector<int> dst(src.size());
    const size_t step = 3;

    std::transform(std::execution::par_unseq,
                   src.begin(), src.end(),
                   dst.begin(),
                   [&src, step](const int& val) {
                       // 通过指针差计算元素索引，仅对索引为step倍数的元素执行转换
                       size_t idx = &val - &src[0];
                       return (idx % step == 0) ? val * 2 : val;
                   });
}

注意：这种方式仅适用于连续存储的容器（如std::vector、std::array），非连续容器（如std::list）无法使用并行执行策略，只能用串行方案。

总结 #

• 串行场景：可自定义迭代器适配器或直接遍历实现需求。
• 并行场景：必须使用标准随机访问迭代器，通过索引判断的方式配合std::transform的并行版本实现，禁止使用自定义迭代器适配器。

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