std::ranges:: views:: slide, std::ranges:: slide_view
|
Definiert in Header
<ranges>
|
||
|
template
<
ranges::
forward_range
V
>
requires
ranges::
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*/
=
|
(3) | ( nur zur Darstellung* ) |
|
template
<
class
V
>
concept
/*slide-caches-last*/
=
|
(4) | ( nur zur Darstellung* ) |
|
template
<
class
V
>
concept
/*slide-caches-first*/
=
|
(5) | ( nur zur Darstellung* ) |
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.
- s - n + 1 , falls s >= n ,
- 0 andernfalls, und die resultierende Ansicht ist leer.
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) |
|
|
(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>
)
|
|
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
>>
=
|
(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, wobeiSdie Größe einer angepasstenviewist, sodassS >= 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) |
|
|
(C++23)
|
eine Range von
view
s
, die
N
-große nicht-überlappende aufeinanderfolgende Teile der Elemente einer anderen
view
sind
(Klassentemplate) (Range-Adapter-Objekt) |