Namespaces
Variants

std::ranges:: views:: slide, std::ranges:: slide_view

From cppreference.net
Ranges library
Range adaptors
Definiert in Header <ranges>
template < ranges:: forward_range V >

requires ranges:: view < V >
class slide_view

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

inline constexpr /* nicht spezifiziert */ slide = /* nicht spezifiziert */ ;

}
(2) (seit C++23)
Aufrufsignatur
template < ranges:: viewable_range R >
constexpr ranges:: view auto slide ( R && r, ranges:: range_difference_t < R > n ) ;
(seit C++23)
template < class DifferenceType >
constexpr /* Bereichsadapterobjekt */ slide ( DifferenceType && n ) ;
(seit C++23)
Hilfskonzepte
template < class V >

concept /*slide-caches-nothing*/ =

ranges:: random_access_range < V > && ranges:: sized_range < V > ;
(3) ( nur zur Darstellung* )
template < class V >

concept /*slide-caches-last*/ =
! /*slide-caches-nothing*/ < V > &&

ranges:: bidirectional_range < V > && ranges:: common_range < V > ;
(4) ( nur zur Darstellung* )
template < class V >

concept /*slide-caches-first*/ =

! /*slide-caches-nothing*/ < V > && ! /*slide-caches-last*/ < V > ;
(5) ( nur zur Darstellung* )
1) slide_view ist ein Range-Adaptor, der eine view und eine Zahl n entgegennimmt und eine View erzeugt, deren m th Element (ein "Fenster") eine Ansicht über [ m , m + n - 1 ] Elemente der ursprünglichen View ist.
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 :: slide bezeichnet ein RangeAdaptorObject . Für die Subausdrücke e und n ist der Ausdruck views :: slide ( e, n ) ausdrucksäquivalent zu slide_view ( e, n ) .

Wenn n nicht größer als 0 ist, ist das Verhalten undefiniert.

slide_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

Member Beschreibung
V base_ die zugrundeliegende View
( exposition-only member object* )
ranges:: range_difference_t < V > n_ die "Fenster"-Größe
( exposition-only member object* )
non-propagating-cache < ranges:: iterator_t < V >> cached_begin_
(present only if V models the slide-caches-first )
ein Objekt, das das Ergebnis von begin() zwischenspeichert
( exposition-only member object* )
non-propagating-cache < ranges:: iterator_t < V >> cached_end_
(present only if V models the slide-caches-last )
ein Objekt, das das Ergebnis von end() zwischenspeichert
( exposition-only member object* )

Memberfunktionen

konstruiert eine slide_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)
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> )

Deduktionshilfen

Geschachtelte Klassen

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

Hilfsvorlagen

template < class V >

constexpr bool ranges:: enable_borrowed_range < slide_view < V >> =

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

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

Hinweise

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-Adapter 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_slide 202202L (C++23) std::ranges::slide_view

Beispiel

#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <ranges>
auto print_subrange = [](std::ranges::viewable_range auto&& r)
{
    std::cout << '[';
    for (char space[]{0,0}; auto elem : r)
        std::cout << space << elem, *space = ' ';
    std::cout << "] ";
};
int main()
{
    const auto v = {1, 2, 3, 4, 5, 6};
    std::cout << "All sliding windows of width:\n";
    for (const unsigned width : std::views::iota(1U, 1U + v.size()))
    {
        auto const windows = v | std::views::slide(width);
        std::cout << "W = " << width << ": ";
        std::ranges::for_each(windows, print_subrange);
        std::cout << '\n';
    }
}

Ausgabe:

All sliding windows of width W:
W = 1: [1] [2] [3] [4] [5] [6] 
W = 2: [1 2] [2 3] [3 4] [4 5] [5 6] 
W = 3: [1 2 3] [2 3 4] [3 4 5] [4 5 6] 
W = 4: [1 2 3 4] [2 3 4 5] [3 4 5 6] 
W = 5: [1 2 3 4 5] [2 3 4 5 6] 
W = 6: [1 2 3 4 5 6]

Referenzen

  • C++23-Standard (ISO/IEC 14882:2024):
  • 26.7.29 Slide-Ansicht [range.slide]

Siehe auch

eine view bestehend aus Tupeln von Referenzen auf benachbarte Elemente der adaptierten View
(Klassentemplate) (Range-Adapter-Objekt)
eine Range von view s , die N -große nicht-überlappende aufeinanderfolgende Teile der Elemente einer anderen view sind
(Klassentemplate) (Range-Adapter-Objekt)