Namespaces
Variants

std::ranges:: views:: adjacent, std::ranges:: adjacent_view, std::ranges:: views:: pairwise

From cppreference.net
C++
Ranges library
Range adaptors
adjacent_view views::adjacent
(C++23) (C++23)
views::pairwise
(C++23)
(C++23) (C++23)
(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_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:: size_t N >

requires ranges:: view < V > && ( N > 0 )
class adjacent_view

: public ranges:: view_interface < adjacent_view < V, N >>
(1) (seit C++23)
namespace views {

template < std:: size_t N >
constexpr /* unspecified */ adjacent = /* unspecified */ ;

}
(2) (seit C++23)
namespace views {

inline constexpr auto pairwise = adjacent < 2 > ;

}
(3) (seit C++23)
Aufrufsignatur
template < ranges:: viewable_range R >

requires /* siehe unten */

constexpr ranges:: view auto adjacent < N > ( R && r ) ;
(seit C++23)
1) adjacent_view ist ein Range-Adaptor, der eine view nimmt und eine view erzeugt, deren i th -tes Element (ein "Fenster") ein std::tuple ist, das N Referenzen auf die Elemente [ i , i + N - 1 ] der ursprünglichen View enthält.
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 < N > bezeichnet ein RangeAdaptorObject . Für einen gegebenen Subausdruck e und einen konstanten Ausdruck N ist der Ausdruck views :: adjacent < N > ( e ) ausdrucksäquivalent zu
3) Der Name views :: pairwise bezeichnet ein RangeAdaptorObject , das sich exakt wie views :: adjacent < 2 > verhält.

adjacent_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

Datenmitglieder

Mitglied Beschreibung
V base_ das zugrundeliegende view
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

Memberfunktionen

konstruiert einen adjacent_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> )

Deduktionsanleitungen

(keine)

Geschachtelte Klassen

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

Hilfsvorlagen

template < class V, size_t N >

constexpr bool ranges:: enable_borrowed_range < adjacent_view < V, N >> =

ranges:: enable_borrowed_range < V > ;
(seit C++23)

Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass adjacent_view borrowed_range erfüllt, wenn die zugrunde liegende View diese Bedingung erfüllt.

Hinweise

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

Es gibt Ähnlichkeiten zwischen ranges::adjacent_view und ranges::slide_view :

  • Beide erzeugen ein "gleitendes Fenster" der Größe N .
  • Beide haben dieselbe Größe S - N + 1 , wobei S die Größe einer angepassten view ist, sodass S >= N > 0 .

Die folgende Tabelle zeigt die Unterschiede zwischen diesen Adaptern:

View-Adaptor value_type Die Fenstergröße N
ranges :: adjacent_view std::tuple Ein Template-Parameter
ranges:: slide_view ranges:: range Ein Laufzeitargument
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

Code ausführen 
#include <array>
#include <format>
#include <iostream>
#include <ranges>
#include <tuple>
int main()
{
    constexpr std::array v{1, 2, 3, 4, 5, 6};
    std::cout << "v = [1 2 3 4 5 6]\n";
    for (int i{}; std::tuple t : v | std::views::adjacent<3>)
    {
        auto [t0, t1, t2] = t;
        std::cout << std::format("e = {:<{}}[{} {} {}]\n", "", 2 * i++, t0, t1, t2);
    }
}

Ausgabe: 

v = [1 2 3 4 5 6]
e = [1 2 3]
e =   [2 3 4]
e =     [3 4 5]
e =       [4 5 6]

Fehlerberichte

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

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

Referenzen

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

Siehe auch

(C++23)
eine view bestehend aus Ergebnissen der Anwendung einer Transformationsfunktion auf benachbarte Elemente der adaptierten view
(Klassen-Template) (Range-Adapter-Objekt)
(C++23)
eine view deren M tes Element eine view über das M te bis (M + N - 1) te Element einer anderen view ist
(Klassen-Template) (Range-Adapter-Objekt)
(C++23)
ein Range von view s , die N -große nicht-überlappende aufeinanderfolgende Teile der Elemente einer anderen view sind
(Klassen-Template) (Range-Adapter-Objekt)
(C++23)
eine view bestehend aus Elementen einer anderen view , die schrittweise über N Elemente fortschreitet
(Klassen-Template) (Range-Adapter-Objekt)