Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
(C++23) (C++23)
(C++23)
adjacent_transform_view views::adjacent_transform
(C++23) (C++23)
views::pairwise_transform
(C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)

std::ranges::adjacent_transform_view
Member functions
(C++26)
Iterator
Member functions
Non-member functions
Sentinel
Member functions
Non-member functions
Definiert im Header <ranges>
template < ranges:: forward_range V, std:: move_constructible F, std:: size_t N >

erfordert 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 /* nicht spezifiziert */ adjacent_transform = /* nicht spezifiziert */ ;

}
(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 >

erfordert /* siehe unten */

constexpr ranges:: view auto adjacent_transform < N > ( R && r, F && fun ) ;
(seit C++23)
template < class F >
constexpr /*Range-Adapter-Closure*/ adjacent_transform < N > ( F && fun ) ;
(seit C++23)
1) adjacent_transform_view ist ein Range-Adapter, der eine view und ein aufrufbares Objekt fun nimmt und eine view erzeugt, deren i tes Element ein Wert ist, der sich aus der Anwendung von fun auf jedes Element im Bereich [ i , i + N ) der ursprünglichen View ergibt. F hat immer Stelligkeit N .
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 Subausdrücke e und f , sowie ein konstanter Ausdruck N , ist der Ausdruck views :: adjacent_transform < N > ( e, f ) ausdrucksäquivalent zu:
3) Der Name views :: pairwise_transform bezeichnet ein RangeAdaptorObject , das sich exakt 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 stets forward_range , und modelliert bidirectional_range , random_access_range , oder sized_range , falls der adaptierte view -Typ das entsprechende Konzept modelliert.

Inhaltsverzeichnis

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 std::ranges::view_interface
gibt zurück ob die abgeleitete Ansicht leer ist, bereitgestellt nur wenn sie sized_range oder forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
(C++23)
gibt einen konstanten Iterator zum Anfang 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, bereitgestellt 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, bereitgestellt wenn sie forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das letzte Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie bidirectional_range und common_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das n te Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie random_access_range erfüllt
(ö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)