std::ranges::fold_left_first

Определён в заголовочном файле <algorithm>

Сигнатура вызова

Определён в заголовочном файле `<algorithm>`
Сигнатура вызова
template< std::input_iterator I, std::sentinel_for<I> S, /indirectly-binary-left-foldable/<std::iter_value_t<I>, I> F > requires std::constructible_from<std::iter_value_t<I>, std::iter_reference_t<I>> constexpr auto fold_left_first( I first, S last, F f );	(1)	(начиная с C++23)
template< ranges::input_range R, /indirectly-binary-left-foldable/<ranges::range_value_t<R>, ranges::iterator_t<R>> F > requires std::constructible_from<ranges::range_value_t<R>, ranges::range_reference_t<R>> constexpr auto fold_left_first( R&& r, F f );	(2)	(начиная с C++23)

template< std::input_iterator I, std::sentinel_for<I> S,
          /*indirectly-binary-left-foldable*/<std::iter_value_t<I>, I> F >
    requires std::constructible_from<std::iter_value_t<I>,
                                     std::iter_reference_t<I>>
constexpr auto fold_left_first( I first, S last, F f );

(1)

(начиная с C++23)

template< ranges::input_range R,
          /*indirectly-binary-left-foldable*/<ranges::range_value_t<R>,
                                              ranges::iterator_t<R>> F >
    requires std::constructible_from<ranges::range_value_t<R>,
                                     ranges::range_reference_t<R>>
constexpr auto fold_left_first( R&& r, F f );

(2)

(начиная с C++23)

Определение /*indirectly-binary-left-foldable*/ см. на этой странице.

Выполняет левостороннюю свёртку элементов исходного диапазона, то есть возвращает результат вычисления цепочки выражений:
f(f(f(f(x₁, x₂), x₃), ...), x_n), где x₁, x₂, ..., x_n — элементы исходного диапазона.

1) Исходный диапазон — [first, last).

2) Исходный диапазон — r.

Функциональные объекты, описанные на этой странице, являются функциональными объектами алгоритмов (неформально называемыми неблоидами), то есть:

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

Параметры

first, last	-	пара итератора и сентинела, задающая исходный диапазон
r	-	исходный диапазон
f	-	бинарный функциональный объект

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

Объект std::optional, содержащий результат левосторонней свёртки, либо не содержащий значения, если исходный диапазон пуст.

Примечания

В следующей таблице сравниваются все алгоритмы свёртки с ограничениями. U ниже — тип результата свёртки; это тип после удаления ссылок и квалификаторов из типа результата F.

Шаблон функции свёртки	Направление	Начальное значение	Возвращаемый тип
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` алгоритмы свёртки

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

struct fold_left_first_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             /*indirectly-binary-left-foldable*/<std::iter_value_t<I>, I> F>
        requires std::constructible_from<std::iter_value_t<I>,
                                         std::iter_reference_t<I>>
    constexpr auto operator()(I first, S last, F f) const
    {
        using U = decltype(ranges::fold_left(std::move(first), last,
                                             std::iter_value_t<I>(*first), f));
        if (first == last)
            return std::optional<U>();
        std::optional<U> init(std::in_place, *first);
        for (++first; first != last; ++first)
            *init = std::invoke(f, std::move(*init), *first);
        return std::move(init);
    }
    
    template<ranges::input_range R,
             /*indirectly-binary-left-foldable*/<ranges::range_value_t<R>,
                                                 ranges::iterator_t<R>> F>
        requires std::constructible_from<ranges::range_value_t<R>,
                                         ranges::range_reference_t<R>>
    constexpr auto operator()(R&& r, F f) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::ref(f));
    }
    
    template<ranges::forward_range R,
             /*indirectly-binary-left-foldable*/<ranges::range_value_t<R>,
                                                 ranges::iterator_t<R>> F>
        requires std::constructible_from<ranges::range_value_t<R>,
                                         ranges::range_reference_t<R>>
    constexpr auto operator()(R&& r, F f) const
    {
        return (*this)(ranges::begin(r),
                       ranges::next(ranges::begin(r), ranges::end(r)),
                       std::ref(f));
    }
};

inline constexpr fold_left_first_fn fold_left_first;

Пример

#include <algorithm>
#include <array>
#include <functional>
#include <ranges>
#include <utility>

int main()
{
    constexpr std::array v{1, 2, 3, 4, 5, 6, 7, 8};
    static_assert
    (
        *std::ranges::fold_left_first(v.begin(), v.end(), std::plus{}) == 36
        && *std::ranges::fold_left_first(v, std::multiplies{}) == 40320
    );
    
    constexpr std::array w
    {
        1, 2, 3, 4, 13,
        1, 2, 3, 4, 13,
        1, 2, 3, 4, 13,
        1, 2, 3, 4,
    };
    static_assert
    (
        "Find the only value that (by precondition) occurs odd number of times:"
        && *std::ranges::fold_left_first(w, [](int p, int q){ return p ^ q; }) == 13
    );
    
    constexpr auto pairs = std::to_array<std::pair<char, float>>
    ({
        {'A', 3.0f},
        {'B', 3.5f},
        {'C', 4.0f}
    });
    static_assert
    (
        "Get the product of all pair::second in pairs:"
        && *std::ranges::fold_left_first
        (
            pairs | std::ranges::views::values, std::multiplies{}
        ) == 42
    );
}

Ссылки

Стандарт C++23 (ISO/IEC 14882:2024):

27.6.18 Свёртка [alg.fold]

См. также

ranges::fold_left (C++23)	выполняет левостороннюю свёртку диапазона элементов (функциональный объект алгоритма)
ranges::fold_right (C++23)	выполняет правостороннюю свёртку диапазона элементов (функциональный объект алгоритма)
ranges::fold_right_last (C++23)	выполняет правостороннюю свёртку диапазона элементов, используя последний элемент в качестве начального значения (функциональный объект алгоритма)
ranges::fold_left_with_iter (C++23)	выполняет левостороннюю свёртку диапазона элементов и возвращает пару (итератор, значение) (функциональный объект алгоритма)
ranges::fold_left_first_with_iter (C++23)	выполняет левостороннюю свёртку диапазона элементов, используя первый элемент в качестве начального значения, и возвращает пару (итератор, необязательное значение) (функциональный объект алгоритма)
accumulate	суммирует или сворачивает диапазон элементов (шаблон функции)
reduce (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_first