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 );

adjacent_transform_view modélise toujours forward_range, et modélise bidirectional_range, random_access_range, ou sized_range, si le type de vue adapté modélise le concept correspondant.

Fonctions membres

Types imbriqués

Membres de données

Classes imbriquées

Notes

views :: adjacent_transform n'accepte que des plages avant même lorsque N est 0 .

Exemple

#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); };
    // Alternativement, Fun pourrait être n'importe quel objet appelable ternaire (si window == 3), par exemple :
    // 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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi