std::ranges::for_each, std::ranges::for_each_result

Определено в заголовке `<algorithm>`
Подпись вызова
template< std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirectly_unary_invocable<std::projected<I, Proj>> Fun > constexpr for_each_result<I, Fun> for_each( I first, S last, Fun f, Proj proj = {} );	(1)	(с C++20)
template< ranges::input_range R, class Proj = std::identity, std::indirectly_unary_invocable< std::projected<ranges::iterator_t<R>, Proj>> Fun > constexpr for_each_result<ranges::borrowed_iterator_t<R>, Fun> for_each( R&& r, Fun f, Proj proj = {} );	(2)	(с C++20)
Вспомогательные типы
template< class I, class F > using for_each_result = ranges::in_fun_result<I, F>;	(3)	(с C++20)

1) Применяет заданный объект функции f к результату проекции значения каждого итератора в диапазоне [first, last), в порядке.

2) То же, что и (1), но использует r в качестве исходного диапазона, как если бы ranges::begin(r) использовалось в качестве first и ranges::end(r) в качестве last.

Для обоих перегрузок, если тип итератора изменяем, f может изменить элементы диапазона через обращённый итератор. Если f возвращает результат, результат игнорируется.

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

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

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

Параметры

first, last	-	пара итератор-маркер диапазона, к которому нужно применить функцию
r	-	диапазон элементов, к которым нужно применить функцию
f	-	функция, которую нужно применить к спроецированному диапазону
proj	-	проекция, которую нужно применить к элементам

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

{std::ranges::next(std::move(first), last), std::move(f)}

Сложность

Ровно last - first применений f и proj.

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

struct for_each_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirectly_unary_invocable<std::projected<I, Proj>> Fun>
    constexpr ranges::for_each_result<I, Fun>
        operator()(I first, S last, Fun f, Proj proj = {}) const
    {
        for (; first != last; ++first)
            std::invoke(f, std::invoke(proj, *first));
        return {std::move(first), std::move(f)};
    }
 
    template<ranges::input_range R, class Proj = std::identity,
             std::indirectly_unary_invocable<std::projected<ranges::iterator_t<R>,
             Proj>> Fun>
    constexpr ranges::for_each_result<ranges::borrowed_iterator_t<R>, Fun>
        operator()(R&& r, Fun f, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(f), std::ref(proj));
    }
};
 
inline constexpr for_each_fn for_each;

Пример

В следующем примере используется лямбда-выражение для увеличения всех элементов вектора, а затем перегруженная operator() в функторе для вычисления их суммы. Обратите внимание, что для вычисления суммы рекомендуется использовать специальный алгоритм std::accumulate.

#include <algorithm>
#include <cassert>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
 
struct Sum
{
    void operator()(int n) { sum += n; }
    int sum {0};
};
 
int main()
{
    std::vector<int> nums {3, 4, 2, 8, 15, 267};
 
    auto print = [](const auto& n) { std::cout << ' ' << n; };
 
    namespace ranges = std::ranges;
    std::cout << "before:";
    ranges::for_each(std::as_const(nums), print);
    print('\n');
 
    ranges::for_each(nums, [](int& n) { ++n; });
 
    // calls Sum::operator() for each number
    auto [i, s] = ranges::for_each(nums.begin(), nums.end(), Sum());
    assert(i == nums.end());
 
    std::cout << "after: ";
    ranges::for_each(nums.cbegin(), nums.cend(), print);
 
    std::cout << "\n" "sum: " << s.sum << '\n';
 
    using pair = std::pair<int, std::string>; 
    std::vector<pair> pairs {{1,"one"}, {2,"two"}, {3,"tree"}};
 
    std::cout << "project the pair::first: ";
    ranges::for_each(pairs, print, [](const pair& p) { return p.first; });
 
    std::cout << "\n" "project the pair::second:";
    ranges::for_each(pairs, print, &pair::second);
    print('\n');
}

Вывод:

before: 3 4 2 8 15 267 
after:  4 5 3 9 16 268
sum: 305
project the pair::first:  1 2 3
project the pair::second: one two tree

См. также

цикл range-`for`(C++11)	выполняет цикл по диапазону
ranges::transform (C++20)	применяет функцию к диапазону элементов (ниблейд)
ranges::for_each_n (C++20)	применяет объект функции к первым 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