# std::ranges::for_each_n, std::ranges::for_each_n_result

< cpp‎ | algorithm‎ | ranges

定义于头文件 `<algorithm>` |  |
调用签名 |  |
template< std::input_iterator I, class Proj = identity, std::indirectly_unary_invocable<std::projected<I, Proj>> Fun > constexpr for_each_n_result<I, Fun> for_each_n( I first, std::iter_difference_t<I> n, Fun f, Proj proj = {}); | (1) | (C++20 起)
辅助类型 |  |
template< class I, class F > using for_each_n_result = ranges::in_fun_result<I, F>; | (2) | (C++20 起)

1) 按顺序应用给定的函数对象 `f` 到用 `proj` 投影的解引用范围 `[first, first + n)` 中的每个迭代器的结果。

若迭代器类型可变，则 `f` 可能通过解引用的迭代器修改范围中的匀速。若 `f` 返回结果，则忽略结果，若 `n` 小于零，则行为未定义。 此页面上描述的仿函数实体是 niebloid ，即：

- 调用它们中的任何一者时不可指定显式模板实参。
- 它们无一对实参依赖查找可见。
- 在通常无限定查找寻找函数调用运算符左侧的名称找到它们之一时，它禁止实参依赖查找。

实际上，它们能以函数对象，或以某些特殊编译器扩展实现。

### 参数

first | - | 代表要应用函数到的范围起始的迭代器
n | - | 要应用函数到的元素数
f | - | 应用到投影后范围 `[first, first + n)` 的函数
proj | - | 应用到元素的投影

### 返回值

对象 {first + n, std::move(f)} ，其中 `first + n` 可能求值为 std::ranges::next(std::move(first), n) ，取决于迭代器类别。

### 复杂度

准确应用 `n` 次 `f` 与 `proj` 。

### 注解

`namespace::ranges` 中的重载要求 `Fun` 实现 `copy_constructible` 。

### 可能的实现

    struct for_each_n_fn {
      template<std::input_iterator I, class Proj = std::identity,
               std::indirectly_unary_invocable<std::projected<I, Proj>> Fun>
        constexpr for_each_n_result<I, Fun>
          operator()(I first, std::iter_difference_t<I> n, Fun fun, Proj proj = Proj{}) const
          {
            for (; n-- > 0; ++first) {
              std::invoke(fun, std::invoke(proj, *first));
            }
            return {std::move(first), std::move(fun)};
          }
    };

    inline constexpr for_each_n_fn for_each_n{};

### 示例

    #include <algorithm>
    #include <array>
    #include <iostream>
    #include <ranges>
    #include <string_view>

    struct P {
        int first; char second;
        friend std::ostream& operator<< (std::ostream& os, const P& p) {
            return os << '{' << p.first << ",'" << p.second << "'}";
        }
    };

    auto print = [](std::string_view name, auto const& v) {
        std::cout << name << ": ";
        for (auto n = v.size(); const auto& e: v) {
            std::cout << e << (--n ? ", " : "\n");
        }
    };

    int main()
    {
        std::array a{1, 2, 3, 4, 5};
        print("a", a);
        // 对前三个数取相反数：
        std::ranges::for_each_n(a.begin(), 3, [](auto& n) { n *= -1; });
        print("a", a);

        std::array s{ P{1,'a'}, P{2, 'b'}, P{3, 'c'}, P{4, 'd'} };
        print("s", s);
        // 用投影对数据成员 'pair::first' 取相反数：
        std::ranges::for_each_n(s.begin(), 2, [](auto& x) { x *= -1; }, &P::first);
        print("s", s);
        // 用投影大写化数据成员 'pair::second' ：
        std::ranges::for_each_n(s.begin(), 3, [](auto& c) { c -= 'a'-'A'; }, &P::second);
        print("s", s);
    }

输出：

    a: 1, 2, 3, 4, 5
    a: -1, -2, -3, 4, 5
    s: {1,'a'}, {2,'b'}, {3,'c'}, {4,'d'}
    s: {-1,'a'}, {-2,'b'}, {3,'c'}, {4,'d'}
    s: {-1,'A'}, {-2,'B'}, {3,'C'}, {4,'d'}

### 参阅

范围 `for` 循环(C++11) | 执行范围上的循环
ranges::for_each (C++20) | 应用函数到范围中的元素 (niebloid)
for_each_n (C++17) | 应用一个函数对象到序列的前 n 个元素 (函数模板)
for_each | 应用函数到范围中的元素 (函数模板)