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)
Défini dans l'en-tête <iterator>
template < std:: input_iterator Iter >
class basic_const_iterator ;
(depuis C++23)

std::basic_const_iterator est un adaptateur d'itérateur qui se comporte exactement comme l'itérateur sous-jacent (qui doit être au moins un LegacyInputIterator ou modéliser input_iterator ), sauf que le déréférencement convertit la valeur retournée par l'itérateur sous-jacent en immuable. Les spécialisations de std::basic_const_iterator sont des itérateurs constants, c'est-à-dire que l'itérateur ne peut jamais être utilisé comme un itérateur de sortie car la modification des éléments n'est pas autorisée.

Table des matières

Types membres

Type de membre Définition
iterator_category
(conditionnellement présent)

Si Iter modélise forward_iterator :

Sinon, il n'y a pas de membre iterator_category .

iterator_concept
value_type std:: iter_value_t < Iter >
difference_type std:: iter_difference_t < Iter >
reference (privé) std:: iter_const_reference_t < Iter >
( type de membre d'exposition uniquement* )

Objets membres

Nombre du membre Définition
current (privé) l'itérateur sous-jacent à partir duquel base() copie ou déplace
( objet membre d'exposition uniquement* )

Fonctions membres

construit un nouveau basic_const_iterator
(fonction membre publique)
accède à l'itérateur sous-jacent
(fonction membre publique)
accède à l'élément pointé
(fonction membre publique)
accède à un élément par index
(fonction membre publique)
avance ou décrémente l'itérateur
(fonction membre publique)
convertit en tout itérateur constant vers lequel un itérateur sous-jacent peut être convertible
(fonction membre publique)
compare les itérateurs sous-jacents
(fonction membre publique)

Fonctions non membres

(C++23)
compare basic_const_iterator avec un itérateur non- basic_const_iterator
(modèle de fonction)
(C++23)
avance ou décrémente l'itérateur
(modèle de fonction)
(C++23)
calcule la distance entre deux adaptateurs d'itérateur
(modèle de fonction)
(C++23)
convertit le résultat du déréférencement de l'itérateur sous-jacent en son type de référence rvalue associé
(fonction)

Classes d'assistance

(C++23)
détermine le type commun d'un itérateur et d'un type basic_const_iterator adapté
(spécialisation de modèle de classe)

Modèles d'alias d'assistance

template < std:: input_iterator I >
using const_iterator = /* voir description */ ;
(depuis C++23)
Traduction effectuée en respectant : - Conservation de tous les tags HTML et attributs - Non-traduction du contenu dans les balises de code - Préservation des termes C++ spécifiques - Traduction professionnelle des commentaires et annotations - "see description" → "voir description" - "since C++23" → "depuis C++23"

Si I modélise constant-iterator (un concept d'exposition uniquement), alors const_iterator < I > dénote un type I . Sinon, basic_const_iterator < I > .

template < std:: semiregular S >
using const_sentinel = /* voir description */ ;
(depuis C++23)

Si S modélise input_iterator , alors const_sentinel < S > dénote un type const_iterator < S > . Sinon, S .

Modèles de fonctions auxiliaires

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

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_ranges_as_const 202207L (C++23) std::basic_const_iterator
202311L (C++23)
(DR) 		std::basic_const_iterator devrait suivre la convertibilité de son type sous-jacent

Exemple

Exécuter ce code 
#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 maintenant
    i[1] = 4; // OK, identique à *(i + 1) = 4;
    auto ci = std::make_const_iterator(i);
    assert(*ci == 4);   // OK, peut lire l'objet sous-jacent
    assert(ci[0] == 4); // OK, idem
    // *ci = 13;        // Erreur : l'emplacement est en lecture seule
    // ci[0] = 13;      // Erreur : idem
    ci.base()[0] = 42;  // OK, l'itérateur sous-jacent est modifiable
    assert(*ci == 42);  // OK, l'emplacement sous-jacent v[0] a été modifié
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
P2836R1 C++23 basic_const_iterator ne respecte pas la convertibilité de son type sous-jacent opérateur de conversion fourni