std::ranges::views::adjacent_transform, std::ranges::adjacent_transform_view, std::ranges::views::pairwise_transform

template< ranges::forward_range V, std::move_constructible F, std::size_t N >
  requires ranges::view<V> && (N > 0) && std::is_object_v<F> &&
           std::regular_invocable<F&,
               /*REPEAT*/(ranges::range_reference_t<V>, N)...> &&
           /*can-reference*/<std::invoke_result_t<F&,
               /*REPEAT*/(ranges::range_reference_t<V>, N)...>>
class adjacent_transform_view
    : public ranges::view_interface<adjacent_transform_view<V, F, N>>

namespace views {
    template< std::size_t N >
    constexpr /* unspecified */ adjacent_transform = /* unspecified */;
}

namespace views {
    inline constexpr auto pairwise_transform = adjacent_transform<2>;
}

template< ranges::viewable_range R, class F >
    requires /* see below */
constexpr ranges::view auto adjacent_transform<N>( R&& r, F&& fun );

template< class F >
constexpr /*range adaptor closure*/ adjacent_transform<N>( F&& fun );

• S - N + 1, если S >= N,
• 0 в противном случае, и результирующее представление пусто.

• ((void)e, views::zip_transform(f)), если N равно 0 и decltype((e)) удовлетворяет требованиям forward_range (за исключением того, что вычисления e и f неопределённо упорядочены),
• adjacent_transform_view<views::all_t<decltype((e))>, std::decay_t<decltype((f))>, N>(e, f) в противном случае.

adjacent_transform_view всегда удовлетворяет требованиям forward_range, а также требованиям bidirectional_range, random_access_range или sized_range, если адаптированный тип view удовлетворяет соответствующей концепции.

Функции-члены

Вложенные типы

Члены данных

Вложенные классы

Примечания

views::adjacent_transform принимает только диапазоны прямого прохода, даже если N — 0.

Пример

#include <array>
#include <iostream>
#include <ranges>

int main()
{
    constexpr static std::array data{1, 2, 3, 4, 5, 6};
    constexpr int window{3};

    auto Fun = [](auto... ints) { return (... + ints); };
    // Alternatively, the Fun could be any ternary (if window == 3) callable, e.g.:
    // auto Fun = [](int x, int y, int z) { return x + y + z; };

    constexpr auto view = data | std::views::adjacent_transform<window>(Fun);

    static_assert(
        view.size() == (data.size() - window + 1)
        && std::array{6, 9, 12, 15}
        == std::array{view[0], view[1], view[2], view[3]}
        && view[0] == Fun(data[0], data[1], data[2])
        && view[1] == Fun(data[1], data[2], data[3])
        && view[2] == Fun(data[2], data[3], data[4])
        && view[3] == Fun(data[3], data[4], data[5])
    );

    for (int x : view)
        std::cout << x << ' ';
    std::cout << '\n';
}

6 9 12 15

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 26.7.27 Представление adjacent transform [range.adjacent.transform]

См. также