Namespaces
Variants

std:: move_iterator

From es.cppreference.net
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
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)
Definido en el encabezado <iterator>
template < class Iter >
class move_iterator ;
(desde C++11)

std::move_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 (desde C++20) , o un concepto de iterador más fuerte (desde C++23) ), excepto que la desreferenciación convierte el valor devuelto por el iterador subyacente en un rvalue. Si este iterador se utiliza como iterador de entrada, el efecto es que los valores se mueven en lugar de copiarse.

Contenidos

Tipos anidados

Tipo Definición
iterator_type Iter
iterator_category std:: iterator_traits < Iter > :: iterator_category
value_type std:: iterator_traits < Iter > :: value_type
difference_type std:: iterator_traits < Iter > :: difference_type
pointer Iter
reference
(hasta C++20)
Tipo Definición
iterator_type Iter
iterator_category
(condicionalmente presente)
iterator_concept

std::input_iterator_tag

(hasta C++23)
(desde C++23)
value_type std:: iter_value_t < Iter >
difference_type std:: iter_difference_t < Iter >
pointer Iter
reference std:: iter_rvalue_reference_t < Iter >
(desde C++20)

Miembros de datos

Miembro Descripción
Iter current el iterador subyacente
( objeto miembro solo para exposición* )

Funciones miembro

construye un nuevo move_iterator
(función miembro pública)
asigna otro move_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 move_iterator
(función miembro pública)

Funciones no miembro

(C++11) (C++11) (eliminado en C++20) (C++11) (C++11) (C++11) (C++11) (C++20)
compara los iteradores subyacentes
(plantilla de función)
compara el iterador subyacente y el centinela subyacente
(plantilla de función)
(C++11)
avanza el iterador
(plantilla de función)
(C++11)
calcula la distancia entre dos adaptadores de iterador
(plantilla de función)
calcula la distancia entre el iterador subyacente y el centinela subyacente
(plantilla de función)
(C++20)
convierte el resultado de desreferenciar el iterador subyacente a su tipo de referencia a valor-r asociado
(función)
(C++20)
intercambia los objetos apuntados por dos iteradores subyacentes
(plantilla de función)
crea un std::move_iterator de tipo inferido del argumento
(plantilla de función)

Plantillas auxiliares

template < class Iterator1, class Iterator2 >

requiere ( ! std:: sized_sentinel_for < Iterator1, Iterator2 > )
constexpr bool disable_sized_sentinel_for

< std :: move_iterator < Iterator1 > , std :: move_iterator < Iterator2 >> = true ;
(desde C++20)

Esta especialización parcial de std::disable_sized_sentinel_for evita que las especializaciones de move_iterator satisfagan sized_sentinel_for si sus iteradores subyacentes no satisfacen el concepto.

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_move_iterator_concept 202207L (C++23) Hacer que std :: move_iterator < T * > sea un iterador de acceso aleatorio

Ejemplo

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <ranges>
#include <string>
#include <string_view>
#include <vector>
void print(const std::string_view rem, const auto& v)
{
    std::cout << rem;
    for (const auto& s : v)
        std::cout << std::quoted(s) << ' ';
    std::cout << '\n';
};
int main()
{
    std::vector<std::string> v{"this", "_", "is", "_", "an", "_", "example"};
    print("Old contents of the vector: ", v);
    std::string concat;
    for (auto begin = std::make_move_iterator(v.begin()),
              end = std::make_move_iterator(v.end());
         begin != end; ++begin)
    {
        std::string temp{*begin}; // moves the contents of *begin to temp
        concat += temp;
    }
    // Starting from C++17, which introduced class template argument deduction,
    // the constructor of std::move_iterator can be used directly:
    // std::string concat = std::accumulate(std::move_iterator(v.begin()),
    //                                      std::move_iterator(v.end()),
    //                                      std::string());
    print("New contents of the vector: ", v);
    print("Concatenated as string: ", std::ranges::single_view(concat));
}

Salida posible:

Old contents of the vector: "this" "_" "is" "_" "an" "_" "example"
New contents of the vector: "" "" "" "" "" "" ""
Concatenated as string: "this_is_an_example"

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
LWG 2106 C++11 desreferenciar un move_iterator podría devolver una referencia colgante
si desreferenciar el iterador subyacente devuelve un prvalue
devuelve el
objeto en su lugar
LWG 3736 C++20 move_iterator carecía de especialización disable_sized_sentinel_for añadida
P2259R1 C++20 el miembro iterator_category se definía incluso si
std:: iterator_traits < Iter > :: iterator_category no está definido
iterator_category no se
define en este caso

Véase también

crea un std::move_iterator del tipo inferido del argumento
(plantilla de función)
adaptador centinela para std::move_iterator
(plantilla de clase)