Dominando std::map em C++: Guia Completo com Exemplos de Código

O que é std::map?

Na Standard Template Library (STL) do C++, std::map é um container associativo que armazena elementos como pares chave-valor. Cada chave é única e o container mantém automaticamente os elementos ordenados de acordo com a função de comparação da chave (por padrão, std::less). Os valores podem ser de qualquer tipo e são acessados através de suas chaves correspondentes.

Por que Usar std::map?

• Chaves são únicas e armazenadas em ordem classificada, tornando operações de busca rápidas (O(log n)).
• Ideal para cenários que requerem array associativo ou dicionário com ordem garantida.
• Implementado internamente como árvore de busca binária balanceada (red-black tree), fornecendo performance confiável em todas as operações.
• Suporta inserção, deleção e travessia rápidas.
• API rica que integra perfeitamente com iteradores e algoritmos STL.

Sintaxe

Declare um map com:

std::map<TipoChave, TipoValor> nomeMapa;

• TipoChave – o tipo da chave (deve ser comparável).
• TipoValor – o tipo do valor mapeado.
• nomeMapa – o nome da variável.

Exemplo:

std::map<std::string, int> mapaIdade;

Tipos Membro

• key_type: Tipo das chaves.
• mapped_type: Tipo dos valores mapeados.
• value_type: std::pair<const key_type, mapped_type>
• iterator: Iterador bidirecional sobre value_type.
• const_iterator, reverse_iterator, const_reverse_iterator
• size_type, difference_type

Funções Embutidas

• begin() – iterador para primeiro elemento.
• end() – iterador past-the-end.
• size() – número de elementos.
• empty() – se o map está vazio.
• insert() – adiciona par chave/valor.
• find() – localiza elemento por chave.
• erase() – remove elementos por iterador ou chave.
• clear() – remove todos os elementos.
• Outros utilitários como count() e lower_bound() também estão disponíveis.

Iterando Sobre Elementos do Map

Iteradores dão controle total sobre ordem de travessia, que é sempre ordenada por chave.

#include <iostream>
#include <string>
#include <map>
using namespace std;
int main() {
    map<int, string> alunos;
    alunos.insert({200, "Alice"});
    alunos.insert({201, "João"});
    cout << "Tamanho do map: " << alunos.size() << endl;
    cout << endl << "Ordem padrão do map:" << endl;
    for (auto it = alunos.begin(); it != alunos.end(); ++it) {
        cout << it->first << ": " << it->second << endl;
    }
    return 0;
}

Saída:

Tamanho do map: 2

Ordem padrão do map:
200: Alice
201: João

Inserindo Dados no std::map

Use insert() para novas entradas; ele rejeita duplicatas silenciosamente. Para sobrescrever uma chave existente, use insert_or_assign().

#include <map>
#include <iostream>
using namespace std;
int main() {
    map<int, int> m{{1,3},{2,4},{3,5}};
    m.insert({5,6});        // adiciona novo par
    m.insert({1,8});        // ignorado, chave 1 já existe
    m.insert_or_assign(1,6); // atualiza chave 1 para valor 6
    cout << "Chave\tElemento\n";
    for (auto& p : m) {
        cout << p.first << '\t' << p.second << '\n';
    }
    return 0;
}

Buscando em um Map

Encontrar uma chave é direto com find(). Se a chave existe, o iterador retornado aponta para o elemento; caso contrário end() é retornado.

#include <iostream>
#include <map>
using namespace std;
int main() {
    map<int, string> alunos;
    alunos.insert({200, "Alice"});
    alunos.insert({201, "João"});
    if (auto it = alunos.find(201); it != alunos.end()) {
        cout << "Chave 201 tem valor: " << it->second << endl;
    }
    return 0;
}

Deletando Dados de um Map

Elementos podem ser removidos por chave ou por iterador. O método erase() invalida apenas iteradores apontando para o elemento apagado.

#include <iostream>
#include <map>
using namespace std;
int main() {
    map<string, int> meuMapa;
    meuMapa["vaca"] = 1;
    meuMapa["gato"] = 2;
    meuMapa["leao"] = 3;
    if (auto it = meuMapa.find("gato"); it != meuMapa.end()) {
        meuMapa.erase(it);
    }
    for (auto& p : meuMapa) {
        cout << p.first << ": " << p.second << endl;
    }
    return 0;
}

Saída:

leao: 3
vaca: 1

Resumo

• std::map é um container associativo ordenado com chaves únicas.
• Chaves fornecem busca eficiente; valores armazenam os dados associados.
• Todas as operações principais executam em tempo logarítmico devido à red-black tree subjacente.
• Iteradores permitem travessia, inserção, deleção e consultas de intervalo.
• Com insert_or_assign(), atualizar valores é direto.
• Use find() para verificações rápidas de existência e acesso direto.
• Operações de erase podem alvejar elementos individuais ou limpar o map inteiro.