Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsadapter
     
    std::ranges::adjacent_transform_view
    Mitgliedsfunktionen
    (C++26)
    Iterator
    Mitgliedsfunktionen
    Nichtmitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nichtmitgliedsfunktionen
     
    Definiert in Header <ranges> 
    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>>
    		(1) (seit C++23) 
    namespace views {
    template< std::size_t N >
    constexpr /* unspecified */ adjacent_transform = /* unspecified */;
}
    		(2) (seit C++23) 
    namespace views {
    inline constexpr auto pairwise_transform = adjacent_transform<2>;
}
    		(3) (seit C++23)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R, class F >
    requires /* see below */
constexpr ranges::view auto adjacent_transform<N>( R&& r, F&& fun );
    		(seit C++23) 
    template< class F >
constexpr /*range adaptor closure*/ adjacent_transform<N>( F&& fun );
    		(seit C++23)
    1) adjacent_transform_view ist ein Bereichsadapter, der eine Ansicht und ein aufrufbares Objekt fun nimmt und eine Ansicht erzeugt, deren ites Element ein Wert ist, der das Ergebnis der Anwendung von fun auf jedes Element in [i, i + N) der ursprünglichen Ansicht ist. F hat immer die Stelligkeit N
    Es sei S die Größe der ursprünglichen Ansicht. Dann ist die Größe der erzeugten Ansicht:
    • S - N + 1, falls S >= N,
    • 0 andernfalls, und die resultierende Ansicht ist leer.
    2) Der Name views::adjacent_transform<N> bezeichnet ein RangeAdaptorObject. Gegeben seien Unterausdrücke e und f und ein konstanter Ausdruck N, der Ausdruck views::adjacent_transform<N>(e, f) ist ausdrucksäquivalent zu:
    • ((void)e, views::zip_transform(f)), falls N gleich 0 ist und decltype((e)) das Konzept forward_range modelliert (außer dass die Auswertungen von e und f unbestimmt sequenziert sind),
    • adjacent_transform_view<views::all_t<decltype((e))>, std::decay_t<decltype((f))>, N>(e, f) andernfalls.
    3) Der Name views::pairwise_transform bezeichnet ein RangeAdaptorObject, das sich genau wie views::adjacent_transform<2> verhält. Insbesondere ist die Stelligkeit von F ebenfalls 2 und fun ist ein binäres aufrufbares Objekt.

    adjacent_transform_view modelliert immer forward_range und modelliert bidirectional_range, random_access_range oder sized_range, wenn der angepasste Ansichtstyp das entsprechende Konzept modelliert.

    Memberfunktionen

    		konstruiert einen adjacent_transform_view
    (öffentliche Elementfunktion)
    		gibt einen Iterator zum Anfang zurück
    (öffentliche Elementfunktion)
    		gibt einen Iterator oder Sentinel zum Ende zurück
    (öffentliche Elementfunktion)
    		gibt die Anzahl der Elemente zurück, bereitgestellt nur wenn der zugrundeliegende (adaptierte) Bereich sized_range erfüllt
    (öffentliche Elementfunktion)
    (C++26)
    		gibt die ungefähre Größe des resultierenden approximately_sized_range zurück
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur wenn sie sized_range oder forward_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete Ansicht nicht leer ist, nur wenn ranges::empty darauf anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Ansicht zurück, wenn sie forward_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Ansicht zurück, nur wenn sie bidirectional_range und common_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das n-te Element in der abgeleiteten Ansicht zurück, nur wenn sie random_access_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)

    Verschachtelte Typen

    Typ Definition
    InnerView (privat) ranges:: adjacent_view < V, N >
    ( Nur zur Darstellung verwendeter Member-Typ* )
    inner_iterator (privat)
    inner_sentinel (privat)

    Datenmitglieder

    Mitglied Beschreibung
    /*movable-box*/ < F > fun_ (privat) das transformierende aufrufbare Objekt
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
    ranges:: adjacent_view < V,N > inner_ (privat) die gespeicherte Ansicht
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

    Geschachtelte Klassen

    		der Iteratortyp
    ( Nur zur Darstellung verwendete Member-Klassenvorlage* )
    		der Sentinel-Typ, verwendet wenn adjacent_transform_view kein common_range ist
    ( Nur zur Darstellung verwendete Member-Klassenvorlage* )

    Hinweise

    views :: adjacent_transform akzeptiert nur Forward-Ranges, selbst wenn N den Wert 0 hat.

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_zip 202110L (C++23) ranges:: zip_view ,
    ranges:: zip_transform_view ,
    ranges:: adjacent_view ,
    ranges::adjacent_transform_view

    Beispiel

    Diesen Code ausführen 
    #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); };
    // Alternativ könnte Fun eine beliebige ternäre (wenn window == 3) aufrufbare Funktion sein, z.B.:
    // 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';
}

    Ausgabe: 

    6 9 12 15

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 4098 C++23 views :: adjacent_transform < 0 > akzeptierte zuvor Input-only-Ranges wird nun abgelehnt

    Referenzen

    • C++23-Standard (ISO/IEC 14882:2024):
    • 26.7.27 Adjacent transform view [range.adjacent.transform]

    Siehe auch

    (C++23)
    		eine view bestehend aus Tupeln von Referenzen auf benachbarte Elemente der adaptierten View
    (Klassentemplate) (Range-Adaptor-Objekt)
    (C++20)
    		eine view einer Sequenz, die eine Transformationsfunktion auf jedes Element anwendet
    (Klassentemplate) (Range-Adaptor-Objekt)
    (C++23)
    		eine view bestehend aus Ergebnissen der Anwendung einer Transformationsfunktion auf entsprechende Elemente der adaptierten Views
    (Klassentemplate) (Customization-Point-Objekt)
    (C++20)
    		wendet eine Funktion auf einen Elementbereich an
    (Algorithmus-Funktionsobjekt)