Namespaces
Variants

std:: basic_const_iterator

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
(C++20)
(C++20)
basic_const_iterator
(C++23)
const_iterator
(C++23)
const_sentinel
(C++23)
make_const_iterator
(C++23)
make_const_sentinel
(C++23)

Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
std::basic_const_iterator
Member functions
Non-member functions
(C++23) (C++23) (C++23) (C++23)
(C++23)
(C++23)
(C++23)
Helper classes
(C++23)
Definiert im Header <iterator>
template < std:: input_iterator Iter >
class basic_const_iterator ;
(seit C++23)

std::basic_const_iterator ist ein Iterator-Adapter, der sich genau wie der zugrundeliegende Iterator verhält (welcher mindestens ein LegacyInputIterator sein oder input_iterator modellieren muss), außer dass die Dereferenzierung den vom zugrundeliegenden Iterator zurückgegebenen Wert als unveränderlich konvertiert. Spezialisierungen von std::basic_const_iterator sind konstante Iteratoren, das heißt, der Iterator kann niemals als Ausgabeiterator verwendet werden, da das Modifizieren von Elementen nicht erlaubt ist.

Inhaltsverzeichnis

Mitgliedertypen

Mitgliedtyp Definition
iterator_category
(bedingt vorhanden)

Falls Iter das Konzept forward_iterator modelliert:

Andernfalls existiert kein Mitglied iterator_category .

iterator_concept
value_type std:: iter_value_t < Iter >
difference_type std:: iter_difference_t < Iter >
reference (privat) std:: iter_const_reference_t < Iter >
( Nur zur Darstellung verwendeter Mitgliedtyp* )

Member-Objekte

Mitgliedername Definition
current (privat) der zugrundeliegende Iterator, von dem base() kopiert oder bewegt
( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

Memberfunktionen

konstruiert einen neuen basic_const_iterator
(öffentliche Elementfunktion)
greift auf den zugrundeliegenden Iterator zu
(öffentliche Elementfunktion)
greift auf das referenzierte Element zu
(öffentliche Elementfunktion)
greift auf ein Element per Index zu
(öffentliche Elementfunktion)
bewegt den Iterator vorwärts oder rückwärts
(öffentliche Elementfunktion)
konvertiert in einen beliebigen konstanten Iterator, in den der zugrundeliegende Iterator konvertierbar ist
(öffentliche Elementfunktion)
vergleicht die zugrundeliegenden Iteratoren
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

(C++23)
vergleicht basic_const_iterator mit Nicht- basic_const_iterator
(Funktions-Template)
(C++23)
erhöht oder verringert den Iterator
(Funktions-Template)
(C++23)
berechnet die Distanz zwischen zwei Iterator-Adaptoren
(Funktions-Template)
(C++23)
konvertiert das Ergebnis der Dereferenzierung des zugrundeliegenden Iterators zu seinem assoziierten Rvalue-Referenztyp
(Funktion)

Hilfsklassen

(C++23)
bestimmt den gemeinsamen Typ eines Iterators und eines angepassten basic_const_iterator -Typs
(Klassen-Template-Spezialisierung)

Hilfs-Alias-Templates

template < std:: input_iterator I >
using const_iterator = /* siehe Beschreibung */ ;
(seit C++23)

Wenn I das Konzept constant-iterator (ein nur zur Darstellung dienendes Konzept) modelliert, dann bezeichnet const_iterator < I > einen Typ I . Andernfalls bezeichnet es basic_const_iterator < I > .

template < std:: semiregular S >
using const_sentinel = /* siehe Beschreibung */ ;
(seit C++23)

Wenn S einen input_iterator modelliert, dann bezeichnet const_sentinel < S > einen Typ const_iterator < S > . Andernfalls S .

Hilfsfunktionsvorlagen

template < std:: input_iterator T >
constexpr const_iterator < T > make_const_iterator ( I it ) { return it ; }
(seit C++23)
template < std:: semiregular S >
constexpr const_sentinel < S > make_const_sentinel ( S s ) { return s ; }
(seit C++23)

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_ranges_as_const 202207L (C++23) std::basic_const_iterator
202311L (C++23)
(DR) 		std::basic_const_iterator sollte der Konvertierbarkeit seines zugrundeliegenden Typs folgen

Beispiel

Diesen Code ausführen 
#include <cassert>
#include <iterator>
#include <vector>
int main()
{
    std::vector v{1, 2, 3};
    std::vector<int>::iterator i = v.begin();
    *i = 4;   // OK, v[0] == 4 jetzt
    i[1] = 4; // OK, dasselbe wie *(i + 1) = 4;
    auto ci = std::make_const_iterator(i);
    assert(*ci == 4);   // OK, kann das zugrundeliegende Objekt lesen
    assert(ci[0] == 4); // OK, ebenso
    // *ci = 13;        // Fehler: Speicherort ist schreibgeschützt
    // ci[0] = 13;      // Fehler: ebenso
    ci.base()[0] = 42;  // OK, zugrundeliegender Iterator ist beschreibbar
    assert(*ci == 42);  // OK, zugrundeliegender Speicherort v[0] wurde modifiziert
}

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
P2836R1 C++23 basic_const_iterator folgt nicht der Konvertierbarkeit seines zugrundeliegenden Typs Konvertierungsoperator bereitgestellt