Objetivos
        
    
    
    
        
Random Access
    
    
        
            
                O tipo de iterador Random Access é um tipo de iterador de acesso randômico para leitura e escrita 
                de valores contidos em estrutura de dado dinâmica , contêiner ou coleção.. Esse iterador é utiizado por 
                Array, Vector, Deque e String.
            
            
                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 | 
                        - | 
                    
                
            
            Características
            
                - Poder ser incrementado
 
                - Poder ser decrementado
 
                - Utilizado para leitura de dados
 
                - Utilizado para escrita de dados
 
                - Aceita mais operadores relacionais
 
            
            
                Para utilizarmos o tipo de dado iterator, precisamos incluir a biblioteca chamada iterator.
            
            Sintaxe A
            #include <iterator>
         
     
    
        
Declaração
    
    
        
            
                A declaração de um objeto do tipo iterator random é feita utilizando o tipo iterador acessado 
                com o operador (::) proveniente da coleção desejada.
            
            Sintaxe
            
tipo_dado<tipo_do_elemento>::iterador nome_iterador;
            Onde
            tipo_dado : tipo de dado que utiliza o iterador randômico.
tipo_do_elemento: tipo de dado do elemento
            
                No exemplo abaixo, vamos utilizar o tipo de dado list para demostração do iterador random. Esse
                tipo de dados pode ser visto com mais detalhes em
                C++ EDD: Vector.
            
            Exemplo 1
            
#include <iostream>
#include <vector>
using namespace std;
int main ()
{
  vector<int> lst = {1,2,3};
  vector<int>::iterator it;
    
  return 0;
}
            Saída
            
-
            Exemplo 1.1
            
#include <iostream>
#include <vector>
using namespace std;
int main()  
{  
    vector<int> vec_int = {1,2,3};
    vector<int>::iterator it = vec_int.begin();
    advance(it,1);
    cout << *it <<endl;
}
}
            Saída
            
2
         
     
    
    
        
            
                Podemos realizar algumas operações aritméticas e relacionais em um iterador do tipo 
                random de acordo com a tabela abaixo:
            
            
                Tab. 2: Operadores
                
                    
                        | Operador | 
                        Exemplo | 
                    
                
                
                    
                        | = | 
                        iterador1 = iterador2 | 
                    
                    
                        | == | 
                        iterador1 == iterador2 | 
                    
                    
                        | != | 
                        iterador1 != iterador2 | 
                    
                    
                        | ++ | 
                        iterador1++ | 
                    
                    
                        | -- | 
                        iterador1-- | 
                    
                    
                        | * | 
                        *iterador1 | 
                    
                    
                        | > | 
                        iterador1 > iterador2 | 
                    
                    
                        | < | 
                        iterador1 < iterador2 | 
                    
                    
                        | >= | 
                        iterador1 >= iterador2 | 
                    
                    
                        | <= | 
                        iterador1 <= iterador2 | 
                    
                
            
            
                No exemplo abaixo, utilizamos o comando for, visto em 
                C++: Comandos de Repetição, em que usamos 
                seus blocos de iniciação, verificação e incremento para declarar expressões usando os operadores 
                vistos acima: 
            
            Exemplo 2
            
#include <iostream>
#include <vector>
using namespace std;
int main ()
{
  vector<int> lst = {1,2,3};
  vector<int>::iterator it;
  
  it = lst.end();
  it--;
  
  if ( it >= lst.begin() && it < lst.end())
    cout<< *it;
    
  return 0;
}
            
            Saída
            
3
            
                Em caso de dúvidas, os operadores acima foram vistos em C++: Operadores e 
                C++: Ponteiros sendo a leitura recomendada.
            
         
     
    
        Histórico de atualizações
        
     
    
        
            
                - 01/08/2025 - revisão 4 - Ajustes pontuais, sintaxes e target de links internos
 
                - 27/09/2024 - revisão 3 - Adição: links internos em 'Operadores'; Ajustes pontuais
 
                - 30/08/2024 - revisão 2 - Correção em links de objetivos
 
                - 09/02/2024 - revisão 1 - correção em navegação, exemplo 1.1 e erros gramaticais
 
                - 30/06/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.