Objetivos
        
    
    
    
        
Iterador
    
    
        
            
                Iterador/Iterator em C++, é um tipo de dado que armazenam referências para acessar elementos 
                contidos em estruturas de dados dinâmicas, containers ou coleções de dados. 
            
            
                Podemos avançar, retroceder e utilizar métodos para obter acesso aos elementos. 
                Nesta introdução vamos estudar de forma superficial os iteradores.
            
            
                Tab. 1: Abstração de um iterador
                
                    
                        | begin | 
                        referência 1 | 
                        referência 2 | 
                        (...)  | 
                        referência N | 
                        end | 
                    
                
                
                    
                        | elemento 1 | 
                        elemento 2 | 
                        elemento 3 | 
                        (...) | 
                        elemento N | 
                        - | 
                    
                
            
            Algumas características
            
                - Iteração sobre estruturas de dados dinâmicas
 
                - São genéricos sem dependência
 
                - Servem como interface para estruturas de dados
 
                - Acesso a elementos via ponteiro
 
                - Direcional, bidirecional e randômico
 
            
            
                Para utilizarmos o tipo de dado iterator, precisamos incluir a biblioteca chamada
                iterator.
            
            Sintaxe
            #include <iterator>
         
     
    
    
        
            
                A declaração de um objeto do tipo iterator depende diretamento do tipo de iterador 
                utilizado. Um estrutura de dados dinâmica deve fornecer um método para que possamos recuperar 
                seu determinado iterador.
            
            Sintaxe: tipo iterator
            
nome_colecao<tipo_dado>::iterator nome_iterador;
            Sintaxe: recuperar iterator
            
nome_colecao.iterator();
            
                No exemplo abaixo, o tipo de dado vector será utilizado no exemplo bem como seu método
                begin que retorna um iterador para o primeiro elemento:
            
            Exemplo 1
            
#include<vector>
#include <iterator>
using namespace std; 
int main()  
{  
    vector<int> vec = {1,2,3};
    vector<int>::iterator it = vec.begin(); //iterador p/ ínicio da coleção.
    cout << *it << endl;
}
            Saída
            
1
            
                Os métodos referentes a cada tipo de iterador serão visto em suas próprias seções. O exemplo 
                acima foi utilizado apenas como demostração básica do uso de um iterador.
            
         
     
    
    
        
            
                Os iteradores em C++ são divididos em 5 tipos de iteradores: Input, Output, 
                Forward, Bidirecional e Random Access que estão resumidos na tabela abaixo:
            
            
                Cada iterador listado abaixo possue seus métodos, operadores e outros recursos que serão estudados em 
                cada uma de suas seções.
            
            
                Tab. 2: Tipos de Iterators
                
                    
                        | Tipo | 
                        Descrição | 
                    
                
                
                    
                        Input | 
                        Iterador somente-leitura e linear. | 
                    
                    
                        Output | 
                        Iteraddor linear e somente-escrita. | 
                    
                    
                        | Forward | 
                        Usado para ler e alterar elementos de forma linear. Iterador de leitura e escrita. | 
                    
                    
                        | Bidirecional | 
                        Iterador Forward com a possibilidade de caminhar em direção contrária. | 
                    
                    
                        | Random access | 
                        Usado para acessar elementos em ordem randômica. | 
                    
                
            
            
                Necesssário conhecimento sobre C++: Ponteiros para os estudo dos tipos 
                de iteradores abaixo.
            
            
                Os iteradores utilizam o conceito de Generics como pode ser visto em 
                C++: Gerenerics > Template com mais
                detalhes.
            
         
     
    
    
        
            
                Os métodos abaixo são os métodos mais comuns relacionados a iteradores. Alguns métodos podem não estar disponíveis 
                para algum determinado tipo de iterador.
            
            
                O incremento, decremento e avanço dos iteradores também possuem restrições de acordo com o tipo de iterador. 
            
            
                Tab. 3: Métodos de Iterator
                
                    
                        | Método | 
                        Descrição | 
                        Quem usa | 
                    
                
                
                    
                        | begin | 
                        Retorna uma referência para o primeiro elemento. | 
                        Todos | 
                    
                    
                        | end | 
                        Retorna uma referência para o fim | 
                        Todos | 
                    
                    
                        | next | 
                        Move iterador para o próximo elemento. | 
                        Forward, Bidirecional | 
                    
                    
                        | prev | 
                        Move o iterador para o elemento anterior. | 
                        Bidirecional | 
                    
                    
                        | advance | 
                        Avança o iterador em N posições. | 
                        Random | 
                    
                
            
            
                No exemplo abaixo, usamos (*) para deferenciar ponteiros a acessar o conteúdo do iterador. 
                Essa assunto pode ser vistos em Ponteiro.
            
            Exemplo 2
            
#include <iostream>
#include <vector>
using namespace std;
int main ()
{
  vector<int> lst = {1,2,3};
  
  vector<int>::iterator ini = lst.begin();
  vector<int>::iterator fim = lst.end();
  
  cout << *ini << endl;
  cout << *--fim << endl;
  
  advance(ini,1);
  cout << *ini << endl;
  
  return 0;
}
            Saída
            
1
3
2
         
     
    
    
        
            
                Como exemplo de estrutura de dados ou coleções que possuem métodos que retornam iteradores, podemos 
                ter as coleções abaixo:
            
            
                Tab. 4: Quem usa iterador
                
                    
                        | Iterador | 
                        Coleção | 
                    
                
                
                    
                        | Bidirecional | 
                        List, Set, Multiset, Map e Multimap | 
                    
                    
                        | Random | 
                        Array, Vector, Deque e String | 
                    
                    
                        | Input | 
                        istream | 
                    
                    
                        | Output | 
                        ostream | 
                    
                    
                        | Forward | 
                        forward_list, unordered_map, unordered_set | 
                    
                
            
            
                Algumas das estruturas de dados mencionadas como Vector, Map e List podem ser estudados em 
                C++: Coleções. Algumas coleções mencionadas
                nas tabela acima serão adicionadas em futuras atualizações.
            
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 01/08/2025 - revisão 3 - Correções: pontuais, sintaxes e links Tab. 2; Adição: forward e random em Tab. 4
 
                - 27/09/2024 - revisão 2 - Correção em Ex. 1; Ajustes pontuais
 
                - 09/02/2024 - revisão 1 - correção em navegação, css e erros gramaticais
 
                - 28/04/2023 - versão inicial
 
            
         
     
    
            
            
                
                    
                    Os cursos oferecidos nesta página são cursos fornecidos por parceiros. Ao comprar um curso clicando
                em seu banner, você está ajudando a manter o projeto TutorialDev vivo. Os sites dos cursos parceiros utilizam cookies.