std::ranges::fold_left
Определён в заголовке <algorithm> | ||
|---|---|---|
| Сигнатура вызова | ||
template< std::input_iterator I, std::sentinel_for<I> S, class T,
/*indirectly-binary-left-foldable*/<T, I> F >
constexpr auto fold_left( I first, S last, T init, F f );
| (1) |
(начиная с C++23) (до C++26) |
template< std::input_iterator I, std::sentinel_for<I> S,
class T = std::iter_value_t<I>,
/*indirectly-binary-left-foldable*/<T, I> F >
constexpr auto fold_left( I first, S last, T init, F f );
| (начиная с C++26) | |
template< ranges::input_range R, class T,
/*indirectly-binary-left-foldable*/
<T, ranges::iterator_t<R>> F >
constexpr auto fold_left( R&& r, T init, F f );
| (2) |
(начиная с C++23) (до C++26) |
template< ranges::input_range R, class T = ranges::range_value_t<R>,
/*indirectly-binary-left-foldable*/
<T, ranges::iterator_t<R>> F >
constexpr auto fold_left( R&& r, T init, F f );
| (начиная с C++26) |
Определение /*indirectly-binary-left-foldable*/ см. на этой странице.
Выполняет свёртку элементов исходного диапазона слева, то есть возвращает результат вычисления цепочки выражений:f(f(f(f(init, x1), x2), ...), xn), где x1, x2, ..., xn — элементы исходного диапазона.
[first, last).r.Функциональные сущности, описанные на этой странице, являются объектами-функциями алгоритмов (неформально называемыми niebloids
Параметры
first, last - пара итератора и сентинела, задающая исходный диапазон
r - исходный диапазон
init - начальное значение свёртки
f - объект бинарной функции
Возвращаемое значение
Результат свёртки слева; если исходный диапазон пуст, это init.
Примечания
В следующей таблице сравниваются все ограниченные алгоритмы свёртки. U ниже — тип результата свёртки; это тип результата F после удаления cv-квалификаторов и ссылок.
| Функция-шаблон свёртки | Направление | Начальное значение | Возвращаемый тип |
|---|---|---|---|
| ranges::fold_left | слева | init | U |
| ranges::fold_left_first | слева | первый элемент | std::optional<U> |
| ranges::fold_right | справа | init | U |
| ranges::fold_right_last | справа | последний элемент | std::optional<U> |
| ranges::fold_left_with_iter | слева | init | (1) ranges::in_value_result<I,U> (2) ranges::in_value_result<BR,U>, где BR — это ranges::borrowed_iterator_t<R> |
| ranges::fold_left_first_with_iter | слева | первый элемент | (1) ranges::in_value_result<I,std::optional<U>> (2) ranges::in_value_result<BR,std::optional<U>> где BR — это ranges::borrowed_iterator_t<R> |
| Макрос проверки возможностей | Значение | Стандарт | Возможность |
|---|---|---|---|
__cpp_lib_ranges_fold | 202207L | (C++23) |
std::ranges алгоритмы свёртки |
__cpp_lib_algorithm_default_value_type | 202403L | (C++26) | Инициализация списком для алгоритмов (1,2) |
Возможные реализации
struct fold_left_fn
{
template<std::input_iterator I, std::sentinel_for<I> S, class T = std::iter_value_t<I>,
/*indirectly-binary-left-foldable*/<T, I> F>
constexpr auto operator()(I first, S last, T init, F f) const
{
using U = std::decay_t<std::invoke_result_t<F&, T, std::iter_reference_t<I>>>;
if (first == last)
return U(std::move(init));
U accum = std::invoke(f, std::move(init), *first);
for (++first; first != last; ++first)
accum = std::invoke(f, std::move(accum), *first);
return std::move(accum);
}
template<ranges::input_range R, class T = ranges::range_value_t<R>,
/*indirectly-binary-left-foldable*/<T, ranges::iterator_t<R>> F>
constexpr auto operator()(R&& r, T init, F f) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::move(init), std::ref(f));
}
template<ranges::forward_range R, class T = ranges::range_value_t<R>,
/*indirectly-binary-left-foldable*/<T, ranges::iterator_t<R>> F>
constexpr auto operator()(R&& r, T init, F f) const
{
return (*this)(ranges::begin(r),
ranges::next(ranges::begin(r), ranges::end(r)),
std::move(init), std::ref(f));
}
};
inline constexpr fold_left_fn fold_left;
|
Пример
#include <algorithm>
#include <complex>
#include <functional>
#include <iostream>
#include <ranges>
#include <string>
#include <utility>
#include <vector>
int main()
{
namespace ranges = std::ranges;
std::vector v{1, 2, 3, 4, 5, 6, 7, 8};
int sum = ranges::fold_left(v.begin(), v.end(), 0, std::plus<int>()); // (1)
std::cout << "sum: " << sum << '\n';
int mul = ranges::fold_left(v, 1, std::multiplies<int>()); // (2)
std::cout << "mul: " << mul << '\n';
// get the product of the std::pair::second of all pairs in the vector:
std::vector<std::pair<char, float>> data {{'A', 2.f}, {'B', 3.f}, {'C', 3.5f}};
float sec = ranges::fold_left
(
data | ranges::views::values, 2.0f, std::multiplies<>()
);
std::cout << "sec: " << sec << '\n';
// use a program defined function object (lambda-expression):
std::string str = ranges::fold_left
(
v, "A", [](std::string s, int x) { return s + ':' + std::to_string(x); }
);
std::cout << "str: " << str << '\n';
using CD = std::complex<double>;
std::vector<CD> nums{{1, 1}, {2, 0}, {3, 0}};
#ifdef __cpp_lib_algorithm_default_value_type
auto res = ranges::fold_left(nums, {7, 0}, std::multiplies{}); // (2)
#else
auto res = ranges::fold_left(nums, CD{7, 0}, std::multiplies{}); // (2)
#endif
std::cout << "res: " << res << '\n';
}
Вывод:
sum: 36 mul: 40320 sec: 42 str: A:1:2:3:4:5:6:7:8 res: (42,42)
Ссылки
- Стандарт C++23 (ISO/IEC 14882:2024):
- 27.6.18 Свёртка [alg.fold]
См. также
|
(C++23) | выполняет свёртку диапазона элементов слева, используя первый элемент в качестве начального значения (объект-функция алгоритма) |
|
(C++23) | выполняет свёртку диапазона элементов справа (объект-функция алгоритма) |
|
(C++23) | выполняет свёртку диапазона элементов справа, используя последний элемент в качестве начального значения (объект-функция алгоритма) |
|
(C++23) | выполняет свёртку диапазона элементов слева и возвращает пару (итератор, значение) (объект-функция алгоритма) |
|
(C++23) | выполняет свёртку диапазона элементов слева, используя первый элемент в качестве начального значения, и возвращает пару (итератор, optional) (объект-функция алгоритма) |
| суммирует или сворачивает диапазон элементов (функция-шаблон) |
|
|
(C++17) | похож на std::accumulate, но элементы обрабатываются не по порядку (функция-шаблон) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/algorithm/ranges/fold_left
