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)
Definido en el encabezado <iterator>
template < std:: input_iterator Iter >
class basic_const_iterator ;
(desde C++23)

std::basic_const_iterator es un adaptador de iterador que se comporta exactamente como el iterador subyacente (que debe ser al menos un LegacyInputIterator o modelar input_iterator ), excepto que la desreferenciación convierte el valor devuelto por el iterador subyacente como inmutable. Las especializaciones de std::basic_const_iterator son iteradores constantes, es decir, el iterador nunca puede usarse como un iterador de salida porque no se permite modificar elementos.

Contenidos

Tipos de miembros

Tipo de miembro Definición
iterator_category
(condicionalmente presente)

Si Iter modela forward_iterator :

De lo contrario, no existe el miembro iterator_category .

iterator_concept
value_type std:: iter_value_t < Iter >
difference_type std:: iter_difference_t < Iter >
reference (privado) std:: iter_const_reference_t < Iter >
( tipo de miembro solo para exposición* )

Objetos miembro

Nombre del miembro Definición
current (privado) el iterador subyacente desde el cual base() copia o mueve
( objeto miembro solo para exposición* )

Funciones miembro

construye un nuevo basic_const_iterator
(función miembro pública)
accede al iterador subyacente
(función miembro pública)
accede al elemento apuntado
(función miembro pública)
accede a un elemento por índice
(función miembro pública)
avanza o decrementa el iterador
(función miembro pública)
convierte en cualquier iterador constante al cual un iterador subyacente pueda ser convertible
(función miembro pública)
compara los iteradores subyacentes
(función miembro pública)

Funciones no miembro

(C++23)
compara basic_const_iterator con iteradores que no son basic_const_iterator
(plantilla de función)
(C++23)
avanza o decrementa el iterador
(plantilla de función)
(C++23)
calcula la distancia entre dos adaptadores de iterador
(plantilla de función)
(C++23)
convierte el resultado de desreferenciar el iterador subyacente a su tipo de referencia de valor asociado
(función)

Clases auxiliares

(C++23)
determina el tipo común de un iterador y un tipo basic_const_iterator adaptado
(especialización de plantilla de clase)

Plantillas de alias auxiliares

template < std:: input_iterator I >
using const_iterator = /* ver descripción */ ;
(desde C++23)

Si I modela constant-iterator (un concepto solo de exposición), entonces const_iterator < I > denota un tipo I . De lo contrario, basic_const_iterator < I > .

template < std:: semiregular S >
using const_sentinel = /* ver descripción */ ;
(desde C++23)

Si S modela input_iterator , entonces const_sentinel < S > denota un tipo const_iterator < S > . De lo contrario, S .

Plantillas de funciones auxiliares

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

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_ranges_as_const 202207L (C++23) std::basic_const_iterator
202311L (C++23)
(DR) 		std::basic_const_iterator debería seguir la convertibilidad de su tipo subyacente

Ejemplo

Ejecutar este código 
#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 ahora
    i[1] = 4; // OK, lo mismo que *(i + 1) = 4;
    auto ci = std::make_const_iterator(i);
    assert(*ci == 4);   // OK, se puede leer el objeto subyacente
    assert(ci[0] == 4); // OK, lo mismo
    // *ci = 13;        // Error: la ubicación es de solo lectura
    // ci[0] = 13;      // Error: lo mismo
    ci.base()[0] = 42;  // OK, el iterador subyacente es escribible
    assert(*ci == 42);  // OK, la ubicación subyacente v[0] fue modificada
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
P2836R1 C++23 basic_const_iterator no sigue la convertibilidad de su tipo subyacente operador de conversión proporcionado