如何编写可转换基础容器中多个值的迭代器包装器？

我有一个依赖迭代器的算法，但在需要转换多个源值时遇到了问题——现有的转换迭代器只能接收单个参数进行转换。

原始代码示例 #

template<typename ForwardIt>
double some_algorithm(ForwardIt begin, ForwardIt end) {
    double result = 0;
    for (auto it = begin; it != end; ++it) {
        double t = *it;
        /*
            do some calculations..
        */
        result += t;
    }
    return result;
}

int main() {
    {
        std::vector<double> distances{ 1, 2, 3, 4 };
        double t = some_algorithm(distances.begin(), distances.end());
        std::cout << t << std::endl;
        /* works great */
    }

    {
        /* 现在处理点集.. */
        std::vector<double> points{ 1, 2, 4, 7, 11 };

        /* 转换为距离值.. */
        std::vector<double> distances;
        distances.resize(points.size() - 1);
        for (size_t i = 0; i + 1 < points.size(); ++i)
            distances[i] = points[i + 1] - points[i];

        /* 调用算法 */
        double t = some_algorithm(distances.begin(), distances.end());
        std::cout << t << std::endl;
    }
}

需求：避免显式生成中间容器 #

我想知道是否存在方法（尤其是使用标准库）创建这类迭代器包装器，从而无需显式生成distances这样的中间值。

理想的迭代器包装器实现 #

template<typename BaseIterator, typename TransformOperator>
struct GenericTransformIterator {
    GenericTransformIterator(BaseIterator it, TransformOperator op) : it(it), op(op) {}

    auto operator*() {
        return op(it);
    }

    GenericTransformIterator& operator++() {
        ++it;
        return *this;
    }

    BaseIterator it;
    TransformOperator op;

    friend bool operator!=(GenericTransformIterator a, GenericTransformIterator b) {
        return a.it != b.it;
    }
};

理想的使用方式 #

{
    /* 处理点集.. */
    std::vector<double> points{ 1, 2, 4, 7, 11 };

    /* 使用通用转换迭代器.. */
    /* 调用算法 */
    auto distance_op = [](auto it) {
        auto next_it = it;
        ++next_it;
        return *next_it - *it;
    };
    double t = some_algorithm(
        generic_transform_iterator(points.begin(), distance_op), 
        generic_transform_iterator(points.end() -1 , distance_op));
    std::cout << t << std::endl;
}

核心思路 #

转换函数不作用于底层对象，而是作用于迭代器（或至少持有索引值，通过lambda捕获整个容器并以索引访问）。我曾使用Boost的各类迭代器包装类，但自C++20及Ranges特性出现后，想了解是否可以用标准库现有工具替代自定义包装器。

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