iterators stl
Uma visão geral completa dos iteradores em STL.
Neste tutorial, examinaremos os detalhes dos iteradores, seus tipos, vantagens e as várias funções que eles suportam.
melhor sistema operacional de código aberto para laptop
O que é um Iterador? Em geral, um iterador é como qualquer objeto que aponta para um elemento específico em um intervalo de dados, como uma matriz ou um contêiner. Um iterador é como um ponteiro em C.
=> Procure toda a série de treinamento C ++ aqui.
O que você aprenderá:
- Visão geral
- Tipos de iteradores
- Vantagens dos iteradores
- Funções do iterador
- Conclusão
- Leitura recomendada
Visão geral
Em STL, um iterador é um objeto que pode ser usado para percorrer ou percorrer os elementos no contêiner usando um conjunto de operadores como operador de incremento (++) ou operador de desreferência (*).
Os iteradores são cruciais na programação STL, pois desempenham um papel importante na conexão dos algoritmos ao contêiner, além de acessar e manipular os dados armazenados dentro dos contêineres.
Tipos de iteradores
Dependendo da funcionalidade implementada pelos iteradores, eles são classificados da seguinte forma:
- Iteradores de entrada e saída : Esses são os tipos mais simplificados de iteradores. Eles são mais úteis em operações sequenciais de entrada-saída contendo passagem única.
- Iteradores para frente : Estes são como os iteradores de entrada, mas têm uma direção, ou seja, direção para frente, no sentido de que podem ser usados para atravessar um intervalo na direção de encaminhamento. Quando os iteradores diretos não são constantes, eles também podem ser usados como iteradores de saída. A maioria dos contêineres STL padrão pelo menos suporta iteradores diretos.
- Iteradores bidirecionais : Estes são semelhantes aos iteradores de encaminhamento, com a única diferença de que são bidirecionais. Isso significa que podemos usar esses iteradores bidirecionais para percorrer o intervalo tanto na direção para frente quanto para trás.
- Iteradores de acesso aleatório : Os iteradores de acesso aleatório são os mais poderosos entre todos os iteradores. Esses são iteradores não sequenciais. Os iteradores de acesso aleatório nos permitem acessar qualquer valor aleatório aplicando um deslocamento ao valor atual sem ter que passar por cada elemento sequencialmente. Eles exibem propriedades semelhantes, como Ponteiros em C.
Uma coisa a ser observada é que nem todos os contêineres STL suportam todos os iteradores. Contêineres diferentes oferecem suporte a iteradores diferentes, dependendo dos requisitos de sua funcionalidade.
Abaixo está a lista de contêineres que usam diferentes iteradores:
Recipientes | Iteradores |
---|---|
Mapa | Bidirecional |
Pilha | Sem iterador |
Fila | Sem iterador |
Fila de prioridade | Sem iterador |
Lista | Bidirecional |
Vetor | Acesso aleatório |
e | Acesso aleatório |
Multimapa | Bidirecional |
Definir | Bidirecional |
Multiset | Bidirecional |
Vantagens dos iteradores
Iteradores são extremamente úteis, especialmente durante a programação usando diferentes intervalos e contêineres.
Algumas das vantagens de usar iteradores na programação podem ser resumidas a seguir:
# 1) Reutilização de código
Contanto que usemos iteradores para acessar elementos em nosso programa, podemos apenas alterar o nome do contêiner em nossa definição de iterador e usar o resto do código de maneira semelhante sempre que precisarmos alterar o contêiner.
Isso é especialmente útil em cenários em que planejamos substituir um contêiner de vetor usando um contêiner de lista. Se no lugar dos iteradores estivéssemos usando o operador [], o código para acessar os elementos seria inútil quando mudássemos os recipientes.
# 2) Facilidade e conveniência de programação
Os iteradores vêm com várias funções embutidas que nos ajudam a percorrer e acessar o conteúdo do contêiner de maneira fácil e conveniente.
Por exemplo , não precisamos ficar verificando o final da lista ou array, como temos que fazer ao usar os operadores [] e precisamos alterar o código do programa como quando queremos adicionar elementos, e precisamos alterá-los para um loop .
Ao usar iteradores, podemos acessar diretamente as funções begin () e end () dos iteradores sem ter que manter uma guia quando chegarmos ao final da lista e também não precisamos alterá-los para um loop.
# 3) Adicionar / Remover Dinâmico
Ao usar iteradores, podemos adicionar ou remover facilmente e dinamicamente os elementos no contêiner sem ter que mudar os elementos como temos que fazer nos operadores [].
Vamos demonstrar isso com o seguinte exemplo:
#include #include using namespace std; int main() { vector vec1 = { 1, 1, 2 }; // Declaring an iterator vector::iterator i; // Inserting element for (i = vec1.begin(); i != vec1.end(); ++i) { if (i == vec1.begin()) { i = vec1.insert(i, 3); // insert 3 at the beginning of vec1 } } // contents of vec1 3 1 1 2 cout<<'Vector contents after addition'; cout< Resultado:
Conteúdo vetorial após adição
3 1 1 2
Conteúdo do vetor após exclusão
3 1 2
Como visto no exemplo acima, vemos que usando iteradores podemos facilmente adicionar ou remover elementos de um contêiner (vetor neste caso), sem ter que recorrer à complexa programação de elementos de deslocamento e reestruturação do contêiner.
Funções do iterador
Como os próprios iteradores são construções integradas, eles suportam várias operações que podem ser feitas em objetos iteradores. Essas operações / funções nos permitem percorrer com eficiência o intervalo e também manipular os elementos dentro do contêiner.
Agora veremos algumas operações principais que os iteradores suportam.
- começar: Retorna a primeira posição ou posição inicial do iterador.
- fim: Retorna a última posição ou 'após a posição final' do iterador.
- anterior: Retorna o novo iterador após diminuir o número de posições fornecidas no argumento.
- Próximo: Retorna um novo iterador após avançar ou incrementar o número de posições fornecidas no argumento.
- insersor: Insere o elemento em qualquer posição em um contêiner.
- avançar: Incrementa a posição do iterador para o número especificado fornecido no argumento.
Demonstraremos o uso de algumas dessas funções / operações no seguinte programa:
#include #include #include using namespace std; int main() { vector v = { 1, 1,2,3,5 }; // declaring iterators to a vector vector::iterator itr1 = v.begin(); vector::iterator itr2 = v.end(); auto it = next(itr1, 2); // displaying iterator position cout << 'Using next() the new iterator is at: '; cout << *it << ' '; cout << endl; auto it1 = prev(itr2, 2); // displaying iterator position cout << 'The position of new iterator using prev() is: '; cout << *it1 << ' '; cout << endl; //advance advance(itr1,3); // displaying iterator position cout << 'After advance operation,itr1 is positioned at: '; cout << *itr1 << ' '; cout << endl; return 0; }
Resultado:
Usando next (), o novo iterador está em: 2
A posição do novo iterador usando prev () é: 3
Após a operação de avanço, itr1 é posicionado em: 3
Usando o programa acima, demonstramos o uso de várias operações de iterador.
Conclusão
Assim, chegamos ao final deste tutorial sobre Iteradores.
Até agora, discutimos os fundamentos do STL, de nosso próximo tutorial em diante, começaremos com os contêineres STL e sua programação.
=> Verifique a série de treinamento C ++ GRATUITA completa aqui.
Leitura recomendada
- Fila prioritária em STL
- Matrizes em STL
- Mais de 70 MELHORES tutoriais em C ++ para aprender programação C ++ GRATUITAMENTE
- Cordas, pares e tuplas em STL
- CONFIGURAR em STL
- Algoritmos em STL
- Best FREE C # Tutorial Series: The Ultimate C # Guide for Beginners
- Biblioteca de modelos padrão (STL): uma breve introdução