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

Определено в заголовке `<algorithm>`
Подпись вызова
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> 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 меньше нуля, поведение не определено.

Функциональные сущности, описанные на этой странице, являются ниблоидами, то есть:

Явные списки шаблонов аргументов не могут быть указаны при вызове ни одной из них.
Ни одна из них не видна для поиска аргументов по зависимостям.
Когда любая из них обнаружена обычным поиском без квалификатора в качестве имени слева от оператора вызова функции, поиск аргументов по зависимостям заблокирован.

На практике они могут быть реализованы как объекты-функции или с помощью специальных расширений компилятора.

Параметры

first	-	Итератор, обозначающий начало диапазона, к которому применяется функция
n	-	Количество элементов, к которым применяется функция
f	-	Функция, применяемая к спроецированному диапазону `[first,` `first + n)`
proj	-	Проекция, применяемая к элементам

Возвращаемое значение

Объект {first + n, std::move(f)}, где first + n может быть вычислен как std::ranges::next(std::move(first), n) в зависимости от категории итератора.

Сложность

Точно n применений f и proj.

Возможная реализация

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);
    // Negate first three numbers:
    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);
    // Negate data members 'P::first' using projection:
    std::ranges::for_each_n(s.begin(), 2, [](auto& x) { x *= -1; }, &P::first);
    print("s", s);
    // Capitalize data members 'P::second' using projection:
    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'}

См. также

цикл range-`for` (C++11)	выполняет цикл по диапазону
ranges::for_each (C++20)	применяет функцию к диапазону элементов (ниблоид)
for_each_n (C++17)	применяет объект-функцию к первым N элементам последовательности (шаблон функции)
for_each	применяет функцию к диапазону элементов (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/ranges/for_each_n