List é um outro tipo de estrutura de dados ou coleção dinâmica que é suportada pela linguagem C++. Os elementos de um lista não são armazenados de forma justaposta sendo armazenados como uma lista duplamente ligada.

Algumas características

1. Genérica
2. Dinâmica
3. Homogêneo
4. Não ordenado
5. Armazena apenas valor
6. Aceita valor repetido

Para utilizarmos esse tipo de dado List, precisamos incluir a biblioteca chamada list. É necessário conhecimento de Generics para compreender melhor esta parte do tutorial.

Sintaxe

#include <list>

A declaração de um objeto do tipo List é feita utilizando o nome do tipo de dado list e o tipo de dado que desejamos utilizar entre < e >. Dessa forma, temos uma estrutura/coleção de dados genérica.

Sintaxe

list<tipo_dado> nome_list; //não iniciado
list<tipo_dado> nome_list = { valor1, valor2, valorN}; //iniciado
list<tipo_dado> nome_list( qtd, valor); //iniciado com valor repetido
list<tipo_dado> nome_list(qtd); //reservada quantidade de elementos não iniciados

Onde

tipo_dado : Tipo de dado utilizando para armazenar os elementos
qtd: número de elementos
valor1..N: valor dos elementos de acordo com tipo_dado
valor: valor que dos elementos repetidos baseados em qtd

Uma list com valores iniciados devem ter seus valores, baseados no tipo de dado utilizado, delimitados por { e } , separados por (,) e terminados com (;):

Exemplo 1

#include <iostream>  
#include <list>
using namespace std; 

using namespace std; 

int main()  
{  
    list<float> lfloat;
    list<int> lint = {1,2,3,4,5};
    list<char> lchar(3,'A');
    list<short> lshort(3);
}

Saída

-

Como o tipo de dado list não podemos acessar seus elementos utilizando seus índices ou posições como argumento para o indexador [], as operações sobre os elementos de uma lista são feitas via método replace da biblioteca <algorithm>.

Sintaxe

public void replace(iterator begin, iterador end, tipo_dado old_value, tipo_dado new_value);

Onde

begin/end: iterador p/ inicio e fim da list
old_value/new_value: valor anterior e valor para alteração

Exemplo 2

#include 
#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

int main()
{
    list<int> lst = {0,1,2};
   
    for(int i: lst) 
        cout<< i << " ";

    cout<< endl;
    
    replace(lst.begin(),lst.end(), 0,999);
            
    for(int i: lst)
        cout<< i << " ";
        
    return 0;
}

Saída

0 1 2 
999 1 2

Para adicionar elementos em uma List, podemos utilizar os métodos push_back e push_front. O primeiro adiciona um elemento no início enquanto o segundo adiciona um elemento do fim.

De forma análoga, para remover elementos em uma List utilizamos os método pop_back e pop_front. O primeiro remove um elemento no início enquanto o segundo remove um elemento do fim.

Sintaxe

public void pop_back();
public void pop_front();
public void push_back(const tipo_dado &val);
public void push_front(const tipo_dado &val);

Onde

val: valor/elemento para adicionar

Exemplo 3

#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

int main()
{
    list<int> lst = {0,1};

    for(int i: lst)
        cout<< i << " ";
        
    lst.push_back(2);
    
    cout<< endl;
    
    for(int i: lst)
        cout<< i << " ";
    
    lst.pop_back();

    cout<< endl;
    
    for(int i: lst)
        cout<< i << " ";

    return 0;
}

Saída

0 1 
0 1 2 
0 1

O número de elementos contidos em uma List pode ser conhecido fazendo uso de seu método público size como pode ser visto abaixo:

Sintaxe

public size();

Exemplo 5

#include <iostream>
#include <list>
using namespace std;

int main()
{
    list<int> lst = {1,2,3};
    cout<< lst.size();
    return 0;
}

Saída

3

Para iterarmos ou percorrermos uma List, podemos utilizar o comando foreach que foi estudado em C++: Comandos de Repetição.

Exemplo 4

#include<iostream>  
#include<list>
using namespace std; 

using namespace std; 

int main()  
{  
    list lint = {1,2,3,4,5};

    for ( int i: lint){
        cout << i << " ";
    } 
} 

Saída

1 2 3 4 5

Podemos utilizar o tipo de dado List como parâmetro de um método ou função assim como qualquer outro tipo de dados como foi visto em C++: Funções. No método ou função definimos uma parâmetro do tipo list.

Sintaxe

tipo_retorno nome_funcao(list<tipo_dado> parametro); //protótipo

Exemplo 5

#include<iostream>  
#include<list>
using namespace std; 

void funcao1(list<int> v)
{
    for ( int i: v){
        cout << i << " ";
    } 
}

int main()  
{  
    list<int> lint = {1,2,3,4,5};
    funcao1(lint);
}

Saída

1 2 3 4 5

O retorno de valor do tipo List em uma função é semelhante ao que já foi visto sobre retorno dos outros tipos de dados em funções. Basta utilizar o comando return ao fim, de uma função ou método, informando uma variável do tipo list que deve ser retornada.

Sintaxe

list<tipo_dado> nome_metodo(lista_parametros)
{
    //corpo omitido
    return variavel_list;
}

Exemplo 6

#include<iostream>  
#include<list>
using namespace std; 

list<int> funcao1()
{
   list<int> i = {1,2,3,4,5};
   return i;
}

int main()  
{  
    list<int> v = funcao1();
    
    for ( int i: v){
        cout << i << " ";
    } 
}
            

Saída

1 2 3 4 5

Para ordenarmos uma List, de forma ascendente, utilizamos o método sort, fornecido pela própria class List. Esse método não recebe argumentos e não possui retorno.

Sintaxe

public void sort();

Onde

-

Exemplo 7

#include <iostream>  
#include <list>

using namespace std;

int main()
{
 list<int> lst = {1,0,3,4,2,5};

 for(int i: lst)
    cout << i << " ";
 cout << endl;   
 lst.sort();
 
 for(int i: lst)
    cout << i << " ";
}
            

Saída

1 0 3 4 2 5 
0 1 2 3 4 5

A classe List fornece métodos para manipular seus dados. Abaixo uma lista de todos os métodos desse classe. É Necesssário o conhecimento de C++: Iteradores e C++: Ponteiros para esta parte do tutorial.

O tipo de dado size_type que será visto em alguns exemplos é um tipo de dado númerico que pode ser um tipo unsigned int ou unsigned long;

reference e iterator vistos abaixo representam os tipos de dados usados na criação de uma list e seus elementos.

Com o método begin, podemos recuperar um iterador que aponta para o primeiro elemento de uma List.

Sintaxe

public iterator begin() noexcept;
const_iterator begin() const noexcept;

Onde

-

Retorno

Iterador apontando para o primeiro elemento da List.

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
 list<int> lst = {0,1,2,3};
 list<int>::iterator it = lst.begin();
 cout << *it;
}

Saída

0

Para remoção de todos os elementos de uma list, utilizamos o método clear. Esse método não possui argumentos e retorno.

Sintaxe

public void clear() noexcept;

Onde

-

Retorno

-

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
 list<int> lst = {0,1,2,3};
 for(int i: lst)
    cout << i << " ";
    
 lst.clear();
 cout << endl << lst.size();
    
}

Saída

0 1 2 3

Para verificar se uma List está vazia ou não, utilizamos o método empty. Esse método não possui argumento e retorna um boolean como resultado da verificação.

Sintaxe

public bool empty() const noexcept;

Onde

-

Retorno

Booleano contendo true se list está vazia ou false caso contrário.

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {0,1,2,3};
    cout<< boolalpha << lst.empty() << endl;
}

Saída

false

Com o método end, podemos recuperar um iterador de uma List que aponta para o seu fim.

Sintaxe

public iterator end() noexcept;
const_iterator end() const noexcept;

Onde

-

Retorno

Iterador apontando para o fim da List.

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {0,1,2,3};
    listor<int>::iterator it = lst.end();
    cout << *--it;
}

Saída

3

Para remover um intervalo de elementos de uma list, podemos utilizar o método erase que recebe uma posição e uma quantidade de caracteres para remoção.

Sintaxe

public iterator erase(const_iterator position); // exclusão até o fim
public iterator erase(const_iterator first, const_iterator last); //exclusão de intervalo

Onde

position:Iterador para a posição de remoção de elemento.
first: Iterador para posição inicial do intervalo.
last: Iterador para posição final do intervalo.

Retorno

Iterador apontando para o elemento seguinte ao elemento removido.

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {0,1,2,3};
    
    for (int i: lst)
        cout << i << " ";
        
    lst.erase(lst.begin());
    
    cout<< endl;
    
    for (int i: lst)
        cout << i << " ";
    return 0;
}

Saída

0 1 2 3 
1 2 3

O método insert é utilizado para inserir um elemento antes de uma posição específica dentro de uma List.

Sintaxe

public iterator insert(const_iterator position, const tipo_dado &val);

iterator insert (const_iterator position, size_type n, const value_type& val);
template <class inputiterator> iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, initializer_list<value_type> il);

Onde

position: iterador para a posição desejada.
val: valor ou elemento que será inserido em position.

Retorno

Iterador que aponta para o novo elemento inserido.

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {1,2,3};
    cout<< list.size() << endl;

    list.insert(lst.begin(),0);

    cout<< list.size() << endl;
    for(int i: lst)
     cout<< i << " ";
    return 0;
}

Saída

3
4
0 1 2 3

O métodos pop_back é utilizados para remover/excluir o elemento do fim de uma List. Esse método não possui argumentos e não retorna valor.

Sintaxe

public void pop_back();

Onde

-

Retorno

-

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {0,1,2,3};
    cout<< lst.size() << endl;

    lst.pop_back();
    lst.pop_back();

    cout<< lst.size() << endl;
    for(int i: lst)
     cout<< i << " ";
    return 0;}

Saída

4
2
0 1

O métodos push_back é utilizados para adicionar um elemento, que é passado como argumento, no fim de uma List. Esse método não retorna valor.

Sintaxe

public void push_back(const tipo_dado &val);
void push_back (value_type&& val);

Onde

val: valor ou elementos para adicionar.

Retorno

-

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {1,2,3};
    cout<< lst.size() << endl;

    lst.push_back(4);

    cout<< lst.size() << endl;
    for(int i: lst)
     cout<< i << " ";
    return 0;
}

Saída

3
4
1 2 3 4

O métodos pop_front é utilizados para remover/excluir o elemento do início de uma List. Esse método não possui argumentos e não retorna valor.

Sintaxe

public void pop_front();

Onde

-

Retorno

-

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {0,1,2,3};
    cout<< lst.size() << endl;

    lst.pop_front();
    lst.pop_front();

    cout<< lst.size() << endl;
    for(int i: lst)
     cout<< i << " ";
    return 0;}

Saída

4
2
2 3

O métodos push_front é utilizados para adicionar um elemento, que é passado como argumento, no início de uma List. Esse método não retorna valor.

Sintaxe

public void push_front(const value_type &val);
void push_front (value_type&& val);

Onde

val: valor ou elementos para adicionar.

Retorno

-

Exemplo

#include <iostream>#include <list>
using namespace std;

int main()
{
    list<int> lst = {1,2,3};
    cout<< lst.size() << endl;

    lst.push_front(4);

    cout<< lst.size() << endl;
    for(int i: lst)
     cout<< i << " ";
    return 0;
}

Saída

3
4
4 1 2 3

Com o método resize podemos redimennsiar uma list para conter umum determinado número de elementos superior ou inferior ao atual.

Sintaxe

public void resize(size_type n);
void resize (size_type n, const value_type& val);

Onde

n: novo número de elementos.

Retorno

-

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {1,2,3,4,5};
    cout<< lst.size() << endl;
    lst.resize(3);
    cout<< lst.size() << endl;
    
    return 0;
}

Saída

5
3

O método size é utilizado para descobrirmos o número de elementos de uma List para iterãção ou outra operação.

Sintaxe

public size_type size() const;

Onde

-

Retorno

Inteiro não sinalizado contendo o número de elementos

Exemplo

#include <iostream>
#include <list>

using namespace std;

int main()
{
    list<int> lst = {1,2,3};
    cout<< lst.size();
    return 0;
}

Saída

3

Caso exista a necessidade de remover elementos repetidos em uma List, podemos utilizar o método unique não recebe argumentos e não possui retorno.

Sintaxe

public void unique();
template <class BinaryPredicate>  void unique (BinaryPredicate binary_pred);

Onde

-

Retorno

Inteiro não sinalizado contendo o número de elementos

Exemplo

#include <iostream>
#include <list>
using namespace std;

int main()  
{  
    list<int> lint = {3,3,2,1};
    lint.unique();
    
    for (int val: lint){
        cout << val << " ";
    }
}

Saída

3 2 1

1. 01/08/2025 - revisão 4 - Correções: pontuais, sintaxes e 'Objetivos', targets e links Tab.1 movidos p/ coluna Nome
2. 27/09/2024 - revisão 3 - Correção: 'Acessando/alterando'; Adição: 'adicionando/removendo', outras correções
3. 30/08/2024 - revisão 2 - Correção em links de objetivos
4. 12/02/2024 - revisão 1 - correção em navegação, css, numeração de exemplos e erros gramaticais
5. 30/06/2023 - versão inicial