Iteradores de vetor C ++

Os principais iteradores em C ++ são iterador de entrada, iterador de saída, iterador para frente, iterador bidirecional e iterador de acesso aleatório. O iterador reverso não é realmente um iterador; É um adaptador de iterador. Existem algumas variantes para os iteradores, como um iterador constante.

Um iterador é um ponteiro elaborado. Como um ponteiro, aponta para objetos do mesmo tipo na memória em momentos diferentes. Todos os iteradores são dereferenciais, exceto o iterador de saída que é dereferenciável apenas para um conjunto de tipos. Dereferenceable significa que o valor apontado pelo ponteiro ou iterador pode ser obtido usando o operador indiretivo, *. Um número inteiro pode ser adicionado a alguns iteradores da mesma maneira e, para o mesmo propósito, o número inteiro seria adicionado a um ponteiro.

As perguntas para este artigo são: O que são esses iteradores? Qual desses iteradores é usado com o vetor C ++? Como esses iteradores são usados ​​com o vetor C ++? Este artigo responde a todas essas perguntas de uma maneira simplificada. No final deste artigo, quando todas essas perguntas teriam sido respondidas, os iteradores do vetor C ++ serão intuitivos e naturais (para o leitor).

Conteúdo do artigo

• Resumo dos Iteradores C ++
• Construção e acesso a vetores
• Acesso à faixa
• Insira iteradores
• Mover iterador
• Conclusão

Resumo dos Iteradores C ++

Iterador de entrada

A idéia de iterador de entrada é para um programa receber o valor de entrada. Ao contrário do iterador de saída, o iterador de entrada é sempre desreferente. Para dois iteradores de entrada, A e B, "A == B" não implica "++ a == ++ b".

Iterador de saída
A idéia de iterador de saída é para um programa liberar valor de saída. Ao contrário do iterador de entrada, o iterador de saída nem sempre é desreferente. É dereferenciável apenas para um conjunto de tipos.

Forward ITERator
O iterador avançado pode escanear o vetor desde o início ao final, um por um (incrementando). Possui todos os requisitos do iterador de entrada, além de requisitos adicionais. Pode substituir um iterador de entrada. Para dois iteradores avançados, A e B, "A == B" implica "++ a == ++ b".

Iterador bidirecional
O iterador bidirecional pode escanear o vetor do início ao fim, um por um. Do final ao início, um por um (decrementando). Possui todos os requisitos do iterador avançado, além de requisitos adicionais. Pode substituir um iterador para a frente. Para dois iteradores bidirecionais, A e B,

"A == b" implica "++ a == ++ b"
e
"-A == -b" implica "a == b".

Itorator de acesso aleatório

O iterador de acesso aleatório tem todos os requisitos do iterador bidirecional, além de requisitos adicionais. Pode substituir um iterador bidirecional. O iterador de acesso aleatório vem com a vantagem de que, se estiver apontando para o primeiro elemento e o quarto elemento é necessário, ele pularia o segundo e o terceiro elementos e apontaria para o quarto elemento. O pular reverso para baixo é verdadeiro.

Iterador reverso

Observe que o C ++ não tem um iterador reverso normal, pois possui um iterador para a frente. Então, há um adaptador chamado de itera reversa. Há mais boas notícias: o iterador reverso atende a todos os requisitos de um iterador bidirecional.

Iterador constante

Se um iterador é considerado um iterador constante, o elemento que aponta para não pode ser modificado.

Construção e acesso a vetores

Os contêineres em C ++ são: Classe Array, Deque, Forward_list, Lista, Vector, Mapa, Definir, UNODERED_MAP e UNODERED_SET. O vetor é um contêiner. Certos modelos de função na biblioteca padrão C ++ operam com iteradores direta ou indiretamente. Contêineres C ++, assim como o vetor, usam essas funções. Essas funções podem ser disponibilizadas para o programa C ++ com uma das seguintes diretivas de inclusão:

#incluir

ou

#incluir

A inclusão de qualquer um dos outros contêineres também disponibilizará esses modelos de função. Um modelo de função é para uma função que pode operar com diferentes tipos de dados. O vetor usa iteradores através desses modelos de função. Alguns dos modelos de função e seu relacionamento com o vetor são os seguintes:

Construção

Função de modelo:

modelo Dados automáticos do Constexpr (C&C) -> Decttype (C.dados());

Auto significa que o tipo de retorno é determinado na avaliação da função. C é o objeto da classe C.

Um exemplo de um objeto vetorial construído com isso implicitamente é:

vetor vtr;

Aqui o objeto, C, está vazio.

Função de modelo:

modelo constExpr const e* dados (Initializer_list il) noexcept;

Aqui, E* é um iterador que aponta para o primeiro elemento da lista ou contêiner. Seu uso com o vetor implicitamente seria com:

vetor vtr 'a', 'b', 'c', 'd', 'e';
vetor:: const_iterator it = vtr.começar();

A função de modelo é mais aplicável à instrução inicial () (a segunda declaração).

Acesso

Função de modelo:

modelo Tamanho automático constExpr (const C&C) -> dTtype (C.tamanho());

Isso retorna o tamanho do contêiner. Exemplo de vetor:

vetor vtr 'a', 'b', 'c', 'd', 'e';
int n = vtr.tamanho();
cout << N << endl;

A saída é 5.

Função de modelo:

modelo [[Nodiscard]] Constexpr bool vazio (Initializer_list il) noexcept;

Retorna true se a lista estiver vazia ou falsa caso contrário. Exemplo de vetor:

vetor vtr 'a', 'b', 'c', 'd', 'e';
bool bl = vtr.vazio();
cout << bl << endl;

A saída é 0 para false.

Acesso à faixa

Existem outras funções de modelo, que usam iteradores que o vetor usa para seus problemas de alcance. Um intervalo é um conjunto consecutivo de elementos de contêiner.

Função de modelo:

modelo Constexpr Auto Begin (C & C) -> Decttype (C.começar());

Isso retorna um iterador apontando para o primeiro elemento da lista. Auto aqui significa que o valor de retorno é determinado na avaliação. Exemplo para vetor:

vetor vtr 'a', 'b', 'c', 'd', 'e';
vetor:: iterator it = vtr.começar();
cout << *it << '\n';

A saída é um. O iterador retornou aqui é um iterador de acesso aleatório. Um iterador de acesso aleatório constante poderia ter sido devolvido - veja mais tarde.

Modelo de função:

modelo ConstExpr Auto End (const C&C) -> Decttype (C.fim());

Retorna um iterador constante apontando para o último elemento da lista. Código vetorial:

vetor vtr 'a', 'b', 'c', 'd', 'e';
vetor:: const_iterator it = vtr.fim();
--isto;
cout << *it << ";
--isto;
cout << *it << endl;

A saída é "e d". Um iterador constante pode ser incrementado ou decrescente, mas o valor que aponta para não pode ser alterado. Um iterador de acesso aleatório normal poderia ter sido devolvido - veja mais tarde.

Modelo de função:

modelo constexpr reverse_iterator RBEGIN (Initializer_list il);

Retorna o último valor na lista. RBEGIN () aponta para o último elemento da lista e não além do último elemento da lista, como end (). Exemplo de vetor:

vetor vtr 'a', 'b', 'c', 'd', 'e';
vetor:: reverse_iterator it = vtr.rBegin ();
cout << *it << ";
++isto;
cout << *it << endl;

A saída é: e d. Com o iterador reverso, ++ tem o efeito oposto para o iterador bidirecional.

Modelo de função:

modelo constexpr reverse_iterator rend (inicializer_list il);

Pontos pouco antes do primeiro elemento da lista. Exemplo de vetor:

vetor vtr 'a', 'b', 'c', 'd', 'e';
vetor:: reverse_iterator it = vtr.rend ();
--isto;
cout << *it << ";
--isto;
cout << *it << endl;

A saída é um B. Com o iterador reverso, - tem o efeito oposto para ++ do iterador bidirecional.

Existem outras funções de modelo neste título - veja mais tarde.

Insira iteradores

reverse_iterator é um adaptador de iterador, não é realmente um iterador. O iterador de inserção também é um adaptador de iterador. Ele satisfaz todos os requisitos do iterador de saída, além de seus próprios requisitos. Existe em três formas em C ++: o back_inserter, o Front_inserter e o Inserter. Cada um deles tem seu próprio construtor.

back_inserter:

Insere na parte de trás!
Protótipos importantes:

explícito back_insert_iterator (contêiner & x);
back_insert_iterator & operator = (contêiner de nome do tipo :: value_type && value);

Exemplo de vetor:
O vetor não tem nenhuma função de membro de inserção que insere na parte traseira. No entanto, a função de membro push_back (t) pode ser vista assim.

FRONT_INSERTER

Inserções na frente!
Protótipos importantes:

Front_insert_iterator explícito (contêiner & x);
FRONT_INSERT_ITERATOR & OPERATOR = (contêiner de nome :: value_type && value);

Exemplo de vetor:
O vetor não tem nenhuma função de membro de inserção que insere na frente. O vetor também não possui a função de membro push_front (t).

A boa notícia é que o vetor insere funções de membro que podem inserir em qualquer lugar, no começo, dentro ou no fim do vetor.

inserter

Este iterador inseriria no início, dentro ou no fim do vetor.

Protótipos importantes:

insert_iterator (contêiner & x, contêiner de tipo de tipo :: iterator i);
insert_iterator & operator = (contêiner de tipo de tipo :: value_type && value);

Exemplo de vetor:

vetor vtr 'a', 'b', 'c', 'd', 'e';
vetor:: iterator it = vtr.começar();
it = it + 2;
vtr.inserir (it, 'c');
para (int i = 0; icout << vtr[i] << ", ";
cout <

A saída é:

A, B, C, C, D, E,

A expressão de inserção do vetor é:

vtr.inserir (it, 'c');

Ele insere o elemento pouco antes do ponteiro (ele) está apontando.

Mover iterador

O Move_Iterator também é um adaptador de iterador. O programa a seguir é semelhante ao exemplo que está na especificação C ++:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

lista chs 'a', 'b', 'c', 'd', 'e';
vetor vtr (make_move_iterator (chs.BEGIN ()), Make_move_iterator (CHS.fim()));
cout << "Original list Content:" << endl;
para (Auto It = CHS.começar(); isto != chs.fim(); IT ++)
cout << *it << ", ";
cout << endl << endl;
cout << "Vector Content:" << endl;
para (int i = 0; icout << vtr[i] << ", ";
cout << endl;
retornar 0;

A saída é:

Conteúdo da lista original:
A, B, C, D, E,

Conteúdo vetorial:
A, B, C, D, E,

Este iterador converte um valor de origem em um Rvalue antes de colocá -lo no destino.

Conclusão

Os principais iteradores em C ++ são iterador de entrada, iterador de saída, iterador para frente, iterador bidirecional e iterador de acesso aleatório. A biblioteca padrão C ++ possui alguns modelos de função que usam esses iteradores. O vetor usa esses iteradores através dos modelos de função. O vetor tem alguns nomes diferentes para alguns desses iteradores. Existem também adaptadores de iterador, que são: reverse_iterator, adaptador de iterador e move_iterator. Algumas variantes de iteradores também existem. Basta incluir em um programa para ter todos esses recursos. Depois de entender o papel desses iteradores, adaptadores e modelos de função que os usam, o uso de iteradores com vetores se torna intuitivo.