C++ Containers

Os containers (recipientes) da biblioteca padrão guardam coleções de valores: uma lista que cresce, um dicionário, um conjunto sem repetidos, uma pilha, uma fila. Esta página reúne os onze mais usados: qual cabeçalho incluir, quando usar cada um, quanto custa cada operação e os métodos principais, com exemplo e o resultado real (83 exemplos compilados e executados com o g++ 15.2, -std=c++23). Para aprender com calma, comece por O que é a STL e std::vector.

Atalhos: Visão geral · Complexidade · Qual usar · vector · array · deque · list · map · unordered_map · set · unordered_set · stack · queue · priority_queue

Exemplo rápido

#include <map>
#include <print>
#include <set>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> compras{"pão", "leite", "café", "leite"};
    compras.push_back("ovos");
    std::println("lista: {} ({} itens)", compras, compras.size());

    std::set<std::string> semRepetir(compras.begin(), compras.end());
    std::println("sem repetir: {}", semRepetir);

    std::map<std::string, int> quantos;
    for (const auto& item : compras) {
        ++quantos[item];
    }
    std::println("quantos: {}", quantos);
}

$ g++ -std=c++23 -Wall -Wextra colecoes.cpp -o colecoes
$ ./colecoes
lista: ["pão", "leite", "café", "leite", "ovos"] (5 itens)
sem repetir: {"café", "leite", "ovos", "pão"}
quantos: {"café": 1, "leite": 2, "ovos": 1, "pão": 1}

O mesmo item, três containers: o vector guarda tudo na ordem em que entrou (com o "leite" repetido), o set guarda cada um uma vez, em ordem, e o map associa cada item a um número. O set e o map ordenam comparando bytes, e por isso "pão" (com ã) veio depois de "ovos".

#include <map>
#include <print>
#include <set>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> compras{"pão", "leite", "café", "leite"};
    compras.push_back("ovos");
    std::println("lista: {} ({} itens)", compras, compras.size());

    std::set<std::string> semRepetir(compras.begin(), compras.end());
    std::println("sem repetir: {}", semRepetir);

    std::map<std::string, int> quantos;
    for (const auto& item : compras) {
        ++quantos[item];
    }
    std::println("quantos: {}", quantos);
}

Visão geral

stack, queue e priority_queue são adaptadores: por dentro usam um deque (ou um vector, no caso da priority_queue) e só mostram as operações permitidas. Por isso não têm begin()/end() e não dá para percorrê-los com for. Desde o C++23 existem também std::flat_map e std::flat_set (<flat_map>, <flat_set>), mapas e conjuntos ordenados guardados num vetor; o g++ 15 já os tem.

Complexidade

Quanto o tempo de cada operação cresce quando o container cresce (n = número de elementos). O(1): constante, não depende do tamanho. O(log n): cresce muito devagar (um milhão de elementos ≈ 20 passos). O(n): proporcional ao tamanho. "Amortizado": quase sempre O(1); de vez em quando, uma operação cara (o vector realocando) que, dividida por todas, some.

Qual usar

std::vector · #include <vector> · Aula

Declaração inicial dos exemplos: std::vector<int> v{10, 20, 30};

std::array · #include <array> · Aula

Declaração inicial dos exemplos: std::array<int, 3> a{10, 20, 30};

std::deque · #include <deque> · Aula

Declaração inicial dos exemplos: std::deque<int> d{10, 20, 30};

std::list · #include <list> · Aula

Declaração inicial dos exemplos: std::list<int> l{30, 10, 20};

std::map · #include <map> · Aula

Declaração inicial dos exemplos: std::map<std::string, int> m{{"bia", 7}, {"ana", 9}};

std::unordered_map · #include <unordered_map> · Aula

Declaração inicial dos exemplos: std::unordered_map<std::string, int> u{{"bia", 7}, {"ana", 9}};

Repare que "caio" apareceu antes dos outros: num unordered_map a ordem é a das "gavetas" internas, e pode mudar quando a tabela cresce.

std::set · #include <set> · Aula

Declaração inicial dos exemplos: std::set<int> s{30, 10, 20};

std::unordered_set · #include <unordered_set> · Aula

Declaração inicial dos exemplos: std::unordered_set<int> us{30, 10, 20};

std::stack · #include <stack> · Aula

Declaração inicial dos exemplos: std::stack<int> p; p.push(10); p.push(20); p.push(30);

O println mostra a pilha de baixo para cima: o último número é o topo.

std::queue · #include <queue> · Aula

Declaração inicial dos exemplos: std::queue<int> f; f.push(10); f.push(20); f.push(30);

O println mostra a fila da frente para o fim: o primeiro número é o próximo a sair.

std::priority_queue · #include <queue> · Aula

Declaração inicial dos exemplos: std::priority_queue<int> pq; pq.push(20); pq.push(50); pq.push(10);

Só o topo é acessível. Para ver todos em ordem, tire um por um com top() e pop().

7 9 10
3 notas diferentes

#include <iostream>
#include <vector>

int main() {
    std::vector<int> notas{7, 9, 7, 10, 9, 7};
    // seu código aqui
}

#include <iostream>
#include <set>
#include <vector>

int main() {
    std::vector<int> notas{7, 9, 7, 10, 9, 7};
    std::set<int> diferentes(notas.begin(), notas.end());
    for (int n : diferentes) {
        std::cout << n << ' ';
    }
    std::cout << '\n' << diferentes.size() << " notas diferentes\n";
}