Namespaces
Variants

Ranges library (since C++20)

From cppreference.net
C++
Ranges library
Range adaptors

Die Ranges-Bibliothek ist eine Erweiterung und Verallgemeinerung der Algorithmen- und Iterator-Bibliotheken, die sie durch bessere Komponierbarkeit und weniger Fehleranfälligkeit leistungsfähiger macht.

Die Bibliothek erstellt und manipuliert Bereichs- views , leichtgewichtige Objekte, die indirekt iterierbare Sequenzen ( ranges ) repräsentieren. Bereiche sind eine Abstraktionsebene über

  • [ begin , end ) – Iterator-Paare, z.B. Bereiche, die durch implizite Konvertierung von Containern erstellt werden. Alle Algorithmen, die Iterator-Paare akzeptieren, haben jetzt Überladungen, die Bereiche akzeptieren (z.B. ranges::sort )
  • begin + [ ​ 0 ​ , size ) – Gezählte Sequenzen, z.B. Bereich zurückgegeben durch views::counted
  • [ begin , predicate ) – Bedingt beendete Sequenzen, z.B. Bereich zurückgegeben durch views::take_while
  • [ begin , .. ) – Unbegrenzte Sequenzen, z.B. Bereich zurückgegeben durch views::iota

Die Ranges-Bibliothek enthält Range-Algorithmen , die sofort auf Ranges angewendet werden, und Range-Adaptoren , die verzögert auf Views angewendet werden. Adaptoren können zu Pipelines zusammengesetzt werden, sodass ihre Aktionen beim Iterieren des Views stattfinden.

Definiert im Header <ranges>
namespace std {

namespace views = ranges :: views ;

}
(seit C++20)

Der Namensbereichs-Alias std::views wird als Kurzform für std::ranges::views bereitgestellt.

**Übersetzungshinweise:** - Alle HTML-Tags und Attribute wurden unverändert beibehalten - C++-spezifische Begriffe (Range access, Range primitives, Views, etc.) wurden nicht übersetzt - Allgemeine Begriffe wie "Contents", "Other utilities", "Notes" etc. wurden professionell ins Deutsche übertragen - Die Formatierung und Struktur bleibt vollständig erhalten - "(since C++23)" wurde zu "(seit C++23)" übersetzt
Definiert im namespace std::ranges

Inhaltsverzeichnis

Range access
Definiert im Header <ranges>
Definiert im Header <iterator>
(C++20)
gibt einen Iterator zum Anfang eines Bereichs zurück
(Anpassungspunktobjekt)
(C++20)
gibt einen Sentinel zurück, der das Ende eines Bereichs anzeigt
(Anpassungspunktobjekt)
(C++20)
gibt einen Iterator zum Anfang eines schreibgeschützten Bereichs zurück
(Anpassungspunktobjekt)
(C++20)
gibt einen Sentinel zurück, der das Ende eines schreibgeschützten Bereichs anzeigt
(Anpassungspunktobjekt)
(C++20)
gibt einen Reverse-Iterator für einen Bereich zurück
(Anpassungspunktobjekt)
(C++20)
gibt einen umgekehrten End-Iterator für einen Bereich zurück
(Anpassungspunktobjekt)
(C++20)
gibt einen Reverse-Iterator für einen schreibgeschützten Bereich zurück
(Anpassungspunktobjekt)
(C++20)
gibt einen umgekehrten End-Iterator für einen schreibgeschützten Bereich zurück
(Anpassungspunktobjekt)
(C++26)
gibt einen Integer-Wert gleich dem Reserve-Hinweis zurück, der von einem Range gegeben wird
(Anpassungspunktobjekt)
(C++20)
gibt eine Ganzzahl gleich der Größe eines Bereichs zurück
(Anpassungspunktobjekt)
(C++20)
gibt einen vorzeichenbehafteten Integer zurück, der gleich der Größe eines Ranges ist
(Anpassungspunktobjekt)
(C++20)
prüft, ob ein Bereich leer ist
(Anpassungspunktobjekt)
(C++20)
erhält einen Zeiger auf den Anfang eines zusammenhängenden Bereichs
(Anpassungspunktobjekt)
(C++20)
erhält einen Zeiger auf den Anfang eines schreibgeschützten zusammenhängenden Bereichs
(Anpassungspunktobjekt)
Bereichsprimitive
Definiert im Header <ranges>
(C++20) (C++23) (C++20) (C++23)
ermittelt Iterator- und Sentinel-Typen eines Ranges
(Alias-Template)
(C++20) (C++20) (C++20)
ermittelt Größen-, Differenz- und Werttypen eines Ranges
(Alias-Template)
(C++20) (C++23) (C++20) (C++20)
erhält Referenztypen eines Bereichs
(Alias-Template)
Behandlung hängender Iteratoren
Definiert im Header <ranges>
(C++20)
Ein Platzhaltertyp, der anzeigt, dass ein Iterator oder ein subrange nicht zurückgegeben werden sollte, da er verwaist wäre
(Klasse)
(C++20)
Ermittelt den Iteratortyp oder subrange -Typ eines borrowed_range
(Alias-Template)
Weitere Hilfsmittel
Definiert im Header <ranges>
(C++23)
kennzeichnet einen Bereich, der als Sequenz statt als einzelner Wert behandelt werden soll
(Klassentemplate)
Range-Konzepte
Definiert im Header <ranges>
(C++20)
gibt an, dass ein Typ ein Range ist, das heißt, es stellt einen begin Iterator und einen end Sentinel bereit
(Konzept)
(C++20)
spezifiziert, dass ein Typ ein range ist und Iteratoren, die von einem Ausdruck davon erhalten werden, sicher zurückgegeben werden können ohne Gefahr von Dangling
(Konzept)
(C++26)
gibt an, dass ein Bereich seine Größe in konstanter Zeit schätzen kann
(Konzept)
(C++20)
spezifiziert, dass ein Bereich seine Größe in konstanter Zeit kennt
(Konzept)
(C++20)
gibt an, dass ein Range eine View ist, d.h. es hat konstante Zeit für Kopieren/Verschieben/Zuweisen
(Konzept)
(C++20)
spezifiziert einen Bereich, dessen Iteratortyp input_iterator erfüllt
(Konzept)
(C++20)
spezifiziert einen Bereich, dessen Iteratortyp output_iterator erfüllt
(Konzept)
(C++20)
spezifiziert einen Bereich, dessen Iteratortyp forward_iterator erfüllt
(Konzept)
(C++20)
spezifiziert einen Bereich, dessen Iteratortyp bidirectional_iterator erfüllt
(Konzept)
(C++20)
spezifiziert einen Bereich, dessen Iteratortyp random_access_iterator erfüllt
(Konzept)
(C++20)
spezifiziert einen Bereich, dessen Iteratortyp contiguous_iterator erfüllt
(Konzept)
(C++20)
spezifiziert, dass ein Range identische Iterator- und Sentinel-Typen besitzt
(Konzept)
(C++20)
spezifiziert die Anforderungen dafür, dass ein range sicher in eine view konvertierbar ist
(Konzept)
(C++23)
spezifiziert, dass ein Bereich schreibgeschützte Elemente besitzt
(Konzept)
Bereichskonvertierungen
Definiert im Header <ranges>
(C++23)
Konstruiert ein neues Nicht-View-Objekt aus einem Eingabebereich
(Funktions-Template)
Ansichten
Definiert im Header <ranges>
(C++20)
Hilfsklassen-Template zur Definition einer view unter Verwendung des Curiously Recurring Template Pattern
(Klassen-Template)
(C++20)
kombiniert ein Iterator-Sentinel-Paar zu einer view
(Klassentemplate)

Range-Fabriken

Definiert im Header <ranges>
Definiert im Namensraum std::ranges
(C++20)
eine leere view ohne Elemente
(Klassen-Template) (Variablen-Template)
(C++20)
eine view die ein einzelnes Element eines bestimmten Werts enthält
(Klassen-Template) (Anpassungspunkt-Objekt)
(C++20)
eine view bestehend aus einer Sequenz, die durch wiederholtes Inkrementieren eines Anfangswerts erzeugt wird
(Klassen-Template) (Anpassungspunkt-Objekt)
(C++23)
eine view bestehend aus einer generierten Sequenz durch wiederholtes Erzeugen desselben Werts
(Klassen-Template) (Anpassungspunkt-Objekt)
(C++20)
eine view bestehend aus den Elementen, die durch sukzessive Anwendung von operator>> auf den assoziierten Eingabestrom erhalten werden
(Klassen-Template) (Anpassungspunkt-Objekt)

Bereichsadapter

Definiert im Header <ranges>
Definiert im namespace std::ranges
(C++23)
Hilfsklassen-Template zur Definition eines Range-Adaptor-Closure-Objekts
(Klassen-Template)
(C++20)
eine view , die alle Elemente eines range enthält
(Alias-Template) (Range-Adapter-Objekt)
(C++20)
eine view der Elemente eines anderen range
(Klassentemplate)
(C++20)
eine view mit exklusivem Besitz eines range
(Klassentemplate)
(C++23)
eine view einer Sequenz, die jedes Element zu einem Rvalue castet
(Klassentemplate) (Range-Adaptor-Objekt)
(C++20)
eine view , die aus den Elementen eines range besteht, die ein Prädikat erfüllen
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view einer Sequenz, die eine Transformationsfunktion auf jedes Element anwendet
(Klassen-Template) (Range-Adapter-Objekt)
(C++20)
eine view bestehend aus den ersten N Elementen einer anderen view
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view , bestehend aus den Anfangselementen einer anderen view , bis zum ersten Element, bei dem ein Prädikat false zurückgibt
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view , bestehend aus Elementen einer anderen view , die die ersten N Elemente überspringt
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view , bestehend aus den Elementen einer anderen view , die das anfängliche Teilsequenz von Elementen überspringt, bis zum ersten Element, wo das Prädikat false zurückgibt
(Klassen-Template) (Range-Adapter-Objekt)
(C++20)
eine view bestehend aus der durch Glätten einer view von range s erhaltenen Sequenz
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine view bestehend aus der Sequenz, die durch das Abflachen einer View von Ranges erhalten wird, mit dem Trennzeichen zwischen Elementen
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view über die Teilbereiche, die durch Aufteilung einer anderen view mittels eines Trennzeichens erhalten werden
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view über die Teilbereiche, die durch Aufteilung einer anderen view mittels eines Trennzeichens erhalten werden
(Klassentemplate) (Range-Adapter-Objekt)
(C++26)
eine view bestehend aus der Verkettung der angepassten Views
(Klassentemplate) (Customization Point Object)
(C++20)
erstellt einen Subrange aus einem Iterator und einer Anzahl
(Anpassungspunktobjekt)
(C++20)
wandelt eine view in einen common_range um
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
eine view , die über die Elemente einer anderen bidirektionalen Ansicht in umgekehrter Reihenfolge iteriert
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
wandelt eine view in einen constant_range um
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
Nimmt eine view bestehend aus tuple-like Werten und eine Zahl N und erzeugt eine view des N ten Elements jedes Tupels
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
nimmt eine view bestehend aus paarartigen Werten und erzeugt eine view der ersten Elemente jedes Paares
(Klassentemplate) (Range-Adapter-Objekt)
(C++20)
nimmt eine view bestehend aus paarartigen Werten und erzeugt eine view der zweiten Elemente jedes Paares
(Klassen-Template) (Range-Adapter-Objekt)
(C++23)
eine view , die jedes Element der adaptierten Sequenz auf ein Tupel aus der Position des Elements und seinem Wert abbildet
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine view bestehend aus Tupeln von Referenzen auf entsprechende Elemente der adaptierten Views
(Klassentemplate) (Customization Point Object)
(C++23)
eine view bestehend aus Ergebnissen der Anwendung einer Transformationsfunktion auf entsprechende Elemente der adaptierten Views
(Klassentemplate) (Customization Point Object)
(C++23)
eine view bestehend aus Tupeln von Referenzen auf benachbarte Elemente der adaptierten view
(Klassentemplate) (Range-Adaptor-Objekt)
(C++23)
eine view bestehend aus Ergebnissen der Anwendung einer Transformationsfunktion auf benachbarte Elemente der adaptierten view
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
ein Bereich von view s , die N -große, nicht überlappende aufeinanderfolgende Teile der Elemente einer anderen view darstellen
(Klassentemplate) (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
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
teilt die view in Subranges zwischen jedem Paar benachbarter Elemente auf, für die das gegebene Prädikat false zurückgibt
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine view , bestehend aus Elementen einer anderen view , die schrittweise über N Elemente voranschreitet
(Klassentemplate) (Range-Adapter-Objekt)
(C++23)
eine view bestehend aus Tupeln von Ergebnissen, die durch das n-äre kartesische Produkt der adaptierten Views berechnet werden
(Klassentemplate) (Anpassungspunktobjekt)
(C++26)
eine view , die das zuletzt abgerufene Element ihrer zugrundeliegenden Sequenz zwischenspeichert
(Klassentemplate) (Range-Adapter-Objekt)
(C++26)
wandelt eine view in einen Bereich um, der ausschließlich ein input_range und kein common_range ist
(Klassentemplate) (Range-Adapter-Objekt)

Bereichsgeneratoren (seit C++23)

Definiert im Header <generator>
Definiert im Namespace std
(C++23)
Eine view , die einen synchronen Coroutine -Generator repräsentiert
(Klassentemplate)

Hilfsobjekte

Bereichsadapter-Objekte

Siehe RangeAdaptorObject (RAO).

Bereichsadapter-Abschluss-Objekte

Siehe RangeAdaptorClosureObject (RACO).

Customization Point Objects

Siehe Customization point object (CPO).

Zuweisungsfähiger Wrapper

Einige Bereichsadapter umschließen ihre Elemente oder Funktionsobjekte mit dem copyable-box (bis C++23) movable-box (seit C++23) . Der Wrapper erweitert das umschlossene Objekt bei Bedarf um Zuweisbarkeit.

Nicht-verbreitender Cache

Einige Bereichsadapter werden mittels einer nur zur Darstellung dienenden Klassenvorlage non-propagating-cache spezifiziert, die sich nahezu wie std:: optional < T > verhält (siehe Beschreibung für Unterschiede).

Bedingt- const Typ

template < bool Const, class T >
using /*maybe-const*/ = std:: conditional_t < Const, const T, T > ;
( Nur zur Darstellung* )

Die Alias-Vorlage /*maybe-const*/ ist eine Kurzschreibweise, die verwendet wird, um bedingt einen const Qualifizierer auf den Typ T anzuwenden.

Integer-ähnliche Typ-Helfer-Templates

template < /*is-integer-like*/ T >
using /*make-signed-like-t*/ < T > = /* siehe Beschreibung */ ;
(1) ( nur zur Darstellung* )
template < /*is-integer-like*/ T >
using /*make-unsigned-like-t*/ < T > = /* siehe Beschreibung */ ;
(2) ( nur zur Darstellung* )
template < /*is-integer-like*/ T >

/*make-unsigned-like-t*/ < T > /*to-unsigned-like*/ ( T t )
{
return static_cast < /*make-unsigned-like-t*/ < T >> ( t ) ;

}
(3) ( nur zur Darstellung* )
1) Für einen integer-like type T :
  • Wenn T ein Integer-Typ ist, /*make-signed-like-t*/ < T > ist std:: make_signed_t < T > .
  • Andernfalls ist /*make-signed-like-t*/ < T > ein entsprechender nicht spezifizierter signed-integer-like type mit derselben Breite wie T .
2) Für einen ganzzahligen Typ T :
  • Wenn T ein Ganzzahltyp ist, dann ist /*make-unsigned-like-t*/ < T > gleich std:: make_unsigned_t < T > .
  • Andernfalls ist /*make-unsigned-like-t*/ < T > ein entsprechender nicht näher spezifizierter vorzeichenloser Ganzzahl-ähnlicher Typ mit derselben Breite wie T .
3) Konvertiert explizit t zu /*make-unsigned-like-t*/ < T > .

Customization Point Object Helfer

template < ranges:: input_range R >

constexpr auto & /*möglicherweise-konstante-Bereich*/ ( R & r ) noexcept
{
if constexpr ( ranges:: input_range < const R > )
return const_cast < const R & > ( r ) ;
else
return r ;

}
(1) ( Nur zur Darstellung* )
template < class T >

constexpr auto /*als-konstante-Zeiger*/ ( const T * p ) noexcept
{
return p ;

}
(2) ( Nur zur Darstellung* )

Einige Bereichszugriffs-Anpassungspunktobjekte werden in Bezug auf diese nur zur Darstellung dienenden Funktionsvorlagen spezifiziert.

1) /*possibly-const-range*/ gibt die const-qualifizierte Version von r zurück, falls const R das Konzept input_range erfüllt; andernfalls wird r ohne jegliche Typumwandlung zurückgegeben.
2) /*as-const-pointer*/ gibt einen Zeiger auf ein Objekt vom konstanten Typ zurück.

Bereichsadapter-Hilfsmittel

(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute unverändert bleiben müssen und die Zelleninhalte leer sind.)
template < class F, class Tuple >

constexpr auto /*tuple-transform*/ ( F && f, Tuple && tuple )
{
return std:: apply ( [ & ] < class ... Ts > ( Ts && ... args )
{
return std:: tuple < std:: invoke_result_t < F & , Ts > ... >
( std:: invoke ( f, std:: forward < Ts > ( args ) ) ... ) ;
} , std:: forward < Tuple > ( tuple ) ) ;

}
(1) ( Nur zur Darstellung* )
template < class F, class Tuple >

constexpr void /*tuple-for-each*/ ( F && f, Tuple && tuple )
{
std:: apply ( [ & ] < class ... Ts > ( Ts && ... args )
{
( static_cast < void > ( std:: invoke ( f, std:: forward < Ts > ( args ) ) ) , ... ) ;
} , std:: forward < Tuple > ( tuple ) ) ;

}
(2) ( exposition only* )
template < class T >

constexpr T & /*als-lvalue*/ ( T && t )
{
return static_cast < T & > ( t ) ;

}
(3) ( Nur zur Darstellung* )

Einige Bereichsadapter werden in Bezug auf diese nur zur Darstellung dienenden Funktionsvorlagen spezifiziert.

1) /*tuple-transform*/ gibt ein neues Tupel zurück, das durch Anwendung von f auf jedes Element des tuple konstruiert wird.
2) /*tuple-for-each*/ wendet f auf jedes Element von tuple an und gibt nichts zurück.
3) /*as-lvalue*/ leitet Rvalue t als Lvalue weiter.

Hilfskonzepte

Die folgenden ausschließlich expository Konzepte werden für mehrere Typen verwendet, sind jedoch nicht Teil der Schnittstelle der Standardbibliothek.

(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur und Formatierung bleiben unverändert.)
template < class R >

Konzept /*simple-view*/ =
ranges:: view < R > && ranges:: range < const R > &&
std:: same_as < ranges:: iterator_t < R > , ranges:: iterator_t < const R >> &&

std:: same_as < ranges:: sentinel_t < R > , ranges:: sentinel_t < const R >> ;
(1) ( nur zur Darstellung* )
template < class I >

concept /*has-arrow*/ =
ranges :: input_iterator < I > &&

( std:: is_pointer_v < I > || requires ( const I i ) { i. operator - > ( ) ; } ) ;
(2) ( nur zur Darstellung* )
template < class T, class U >

concept /*different-from*/ =

! std:: same_as < std:: remove_cvref_t < T > , std:: remove_cvref_t < U >> ;
(3) ( Nur zur Darstellung* )
template < class R >

Konzept /*range-with-movable-references*/ =
ranges:: input_range < R > &&
std:: move_constructible < ranges:: range_reference_t < R >> &&

std:: move_constructible < ranges:: range_rvalue_reference_t < R >> ;
(4) ( nur zur Darstellung* )
template < bool C, class ... Views >

Konzept /*all-random-access*/ =
( ranges:: random_access_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(5) ( Nur zur Darstellung* )
template < bool C, class ... Views >

Konzept /*all-bidirectional*/ =
( ranges:: bidirectional_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(6) ( Nur zur Darstellung* )
template < bool C, class ... Views >

Konzept /*all-forward*/ =
( ranges:: forward_range

< std:: conditional_t < C, const Views, Views >> && ... ) ;
(7) ( Nur zur Darstellung* )

Hinweise

Feature-Test Makro Wert Std Funktion
__cpp_lib_generator 202207L (C++23) std:: generator – synchroner Koroutinen-Generator für Bereiche
__cpp_lib_ranges 201911L (C++20) Ranges-Bibliothek und eingeschränkte Algorithmen
202106L (C++23)
(DR20) 		Nicht- default-initializable views
202110L (C++23)
(DR20) 		Views mit Besitz
202202L (C++23) ranges:: range_adaptor_closure
202207L (C++23) Lockerung der Range-Adapter zur Unterstützung von nur-verschiebbaren Typen
202211L (C++23) Entfernen der "Poison Pill" (P2602) Überladungen in ranges:: begin etc
202302L (C++23) Lockerung von Ranges zur Erlaubnis bestimmter Projektionen
202406L (C++26)
(DR20) 		Entfernen der Common-Reference-Anforderung aus den indirekt aufrufbaren Konzepten
__cpp_lib_ranges_as_const 202207L (C++23) std:: const_iterator , ranges:: as_const_view
__cpp_lib_ranges_as_rvalue 202207L (C++23) ranges:: as_rvalue_view
__cpp_lib_ranges_cache_latest 202411L (C++26) ranges :: cache_latest_view
__cpp_lib_ranges_cartesian_product 202207L (C++23) ranges:: cartesian_product_view
__cpp_lib_ranges_chunk 202202L (C++23) ranges:: chunk_view
__cpp_lib_ranges_chunk_by 202202L (C++23) ranges:: chunk_by_view
__cpp_lib_ranges_concat 202403L (C++26) ranges:: concat_view
__cpp_lib_ranges_enumerate 202302L (C++23) ranges :: enumerate_view
__cpp_lib_ranges_join_with 202202L (C++23) ranges:: join_with_view
__cpp_lib_ranges_repeat 202207L (C++23) ranges:: repeat_view
__cpp_lib_ranges_reserve_hint 202502L (C++26) ranges :: reserve_hint und ranges :: approximately_sized_range
__cpp_lib_ranges_slide 202202L (C++23) ranges:: slide_view
__cpp_lib_ranges_stride 202207L (C++23) ranges:: stride_view
__cpp_lib_ranges_to_container 202202L (C++23) ranges:: to
__cpp_lib_ranges_to_input 202502L (C++26) ranges :: to_input_view
__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 <iostream>
#include <ranges>
int main()
{
    auto const ints = {0, 1, 2, 3, 4, 5};
    auto even = [](int i) { return 0 == i % 2; };
    auto square = [](int i) { return i * i; };
    // die "Pipe"-Syntax zur Komposition der Views:
    for (int i : ints | std::views::filter(even) | std::views::transform(square))
        std::cout << i << ' ';
    std::cout << '\n';
    // eine traditionelle "funktionale" Kompositionssyntax:
    for (int i : std::views::transform(std::views::filter(ints, even), square))
        std::cout << i << ' ';
}

Ausgabe: 

0 4 16
0 4 16

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 3509
( P2281R1 ) 		C++20 Es war unklar, wie Range-Adapter-Objekte nachfolgende Argumente binden Sie werden
als Wert gebunden
LWG 3948 C++23 possibly-const-range und as-const-pointer
waren nicht als noexcept deklariert 		Als noexcept deklariert
LWG 4027 C++23 possibly-const-range würde keine Const-Qualifizierung hinzufügen
für Ranges, die bereits constant_range modelliert haben 		Fügt Const-Qualifizierung
für solche Ranges hinzu
LWG 4112 C++20 has-arrow erforderte nicht, dass i const-qualifiziert ist Erfordert es

Siehe auch