Map é um outro tipo de estrutura de dados ou coleção dinâmica que também é suportada pela linguagem C++. Os elementos de um Map são armazenados na forma de chave-valor. Em outras linguagens é conhecido como dicionário ou hashmap.

Algumas características

1. Genérica
2. Dinâmica
3. Heterogênea
4. Ordenada
5. Armazena chave-valor
6. Não aceita chave repetida

Para utilizarmos esse tipo de dado Map, precisamos incluir sua biblioteca e tamébem é necessário ter conhecimento de C++: Generics para compreender melhor esta parte do tutorial.

Sintaxe

#include <map>

Para armazenar informações do tipo chave-valor na linguagem C++, o tipo de dado pair é utilizado como mostrado na sintaxe abaixo:

Sintaxe 1

pair<tipo_dado_chave, tipo_dado_valor> 

Onde

tipo_dado_chave : Tipo de dado usado para armazenar as chaves
tipo_dado_valor: Tipo de dado usado para armazenar os valores

O tipo de dado pair, possui dois atributos, first e second, que armazenam os valores chave e valor respectivamente. O acesso a esses atributos é visto na sintaxe a seguir:

Sintaxe 2

nome_variavel_pair.first;
nome_variavel_pair.second;

A declaração de uma variável do tipo Map é feita utilizando o nome do tipo de dado Map e os tipos de dados que desejamos utilizar para armazenar as chaves e valores como mostra abaixo:

Sintaxe

map<tipo_dado_chave, tipo_dado_valor> nome_list; //não iniciado
map<tipo_dado_chave, tipo_dado_valor> nome_list = {{chave1, valor1},{chave2,valor2},...}; //iniciado

Onde

tipo_dado_chave : Tipo de dado usado para armazenar as chaves
tipo_dado_valor: Tipo de dado usado para armazenar os valores

Exemplo 1

#include<map>
#include<string>

using namespace std; 

int main()  
{  
    map<int,string> mInt;
    map<int,float>  mFloat = {{1,1.99},{2,2.99}};
} 

Saída

-

O acesso aos elementos contidos no tipo de dado Map é feito informando a chave que desejamos acessar como argumento para o indexador [] de forma semelhante ao que foi visto para arrays/vetores.

Sintaxe

nome_variavel_map[chave];

Onde

chave : Chave associada ao valor desejado para acessar.

Exemplo 2

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

int main()  
{  
    map<int,string> mInt;
    map<int,float>  mFloat = {{1,1.23},{2,2.34}};
    
    cout << mFloat[2];
}

Saída

2.34
            

Para alterar um valor contido em uma posição de um map, basta usar operador de atribuição (=) e o novo valor desejado de acordo com o tipo de dado definido na declaração do Map.

Sintaxe

nome_variavel_map[chave] = valor;

Exemplo 3

#include<map>
using namespace std;

int main()  
{  
    map<int,string> mInt;
    map<int,float>  mFloat = {{1,1.23},{2,2.34}};
    
     //acessando chave 1
    cout<< mFloat[1] << endl;
    
    //atualizando chave 2
    mFloat[2] = 7.77;
    cout<< mFloat[2] << endl;

}

Saída

2.34
7.77

Para adicionar elementos em um Map, utilizamo o método insert que recebe um pair contendo a chave e valor para inserção como argumento.

Para remover elementos em um Map, utilizamos os método erase que recebe uma chave como argumento para exclusão.

Sintaxe

public pair<iterator,bool> insert(const tipo_dado &val);

public size_type erase(const tipo_dado_chave &k);

Onde

-

Exemplo 4

#include<map>
#include<string>
#include<iostream>

using namespace std; 

int main()  
{  
    map<int,string> mInt ={};
    
    mInt.insert(pair<int,string>(1,"abc"));
    mInt.insert(pair<int,string>(2,"def"));
    mInt.insert(pair<int,string>(3,"ghi"));
    
    for(pair<int,string> p : mInt)
        cout<< p.first << "-" << p.second<< endl;
    
    mInt.erase(2);
    
    cout<< endl;
    
    for(pair<int,string> p : mInt)
        cout<< p.first << "-" << p.second<< endl;
} 

Saída

1-abc
2-def
3-ghi

1-abc
3-ghi

Para iterarmos ou percorrermos um Map, podemos utilizar o comando foreach que foi estudado em Comandos de repetição : foreach. O tipo pair deve ser utilizado para receber os elementos do Map.

Exemplo 5

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

int main()  
{  
    map<int,int>  mInt = {{1,2},{2,3}};
    
    for( pair<int,int> p: mInt)
        cout<< "{" << p.first << "," << p.second << "}" << endl; 
}

Saída

{1,2}
{2,3}

Um map pode ser percorrido utilizando um iterador em conjunto com o comando for. Nessa forma, um iterador é utilizado para a iteração e o acesso aos elementos é feito utilizando ponteiros.

Exemplo 6

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

int main()  
{  
    map<int,int>  m = {{1,100},{2,200}};
    
    map<int,int>::iterator it;
    
    for ( it = m.begin();  it != m.end();it++){
        cout << (*it).first << ": " ;
        cout << it->second << endl;
    }  
} 

Saída

1: 100
2: 200

O número de elementos contidos em um Map pode ser conhecido fazendo uso do método count como pode ser visto abaixo:

Sintaxe

public size_type count() const;

Exemplo 7

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

int main()
{
    map<int> mmap = {{1,2},{3,4}};
    cout<< mmap.count();
    return 0;
}

Saída

2

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

Sintaxe

tipo_retorno nome_funcao(map<tipo_chave,tipo_valor> parametro); //protótipo

Exemplo 8

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

void funcao(map<int,int> m){
  
    map<int,int>::iterator it;
    
    for( pair<int,int> p: mInt)
        cout<< "{" << p.first << "," << p.second << "}" << endl; 
    }  
}

int main()  
{  
    map<int,int>  mInt = {{1,100},{2,200}};
    
    funcao(mInt);
} 

Saída

{1: 100}
{2: 200}

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

Sintaxe

map<tipo_chave,tipo_valor> nome_funcao(map<tipo_chave,tipo_valor> parametro)
{
    //omitido
    return nome_var_map;
}
            

Exemplo 9

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

map<int,int> funcao(){
  
  map<int,int>  mInt = {{1,100},{2,200}};
  return mInt;
}

int main()  
{  
    map<int,int>  mInt = funcao();
    
    for( pair<int,int> p: mInt)
        cout<< "{" << p.first << "," << p.second << "}" << endl; 
}
            

Saída

{1,100}
{2,200}

A classe Map fornece métodos para manipular seus dados. Abaixo uma lista de todos os métodos dessa classe. Necesssário conhecimento básico C++: Iteradores e 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;

Os termos reference e iterator representam os tipos de dados usados na criação de um Map para suas chaves e/ou valores.

Com o método at podemos recuperar uma referência para o valor cuja chave é passada como argumento.

Sintaxe

public reference &at(const tipo_chave &k);
const mapped_type& at(const key_type& k) const;

Onde

reference: reference de retorno para tipo de dado do valor
k: chave do elemento

Retorno

Referencia para o valor associado a chave k.

Exemplo 1

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

int main()
{
    map<int,int>  mInt = {{1,100},{2,200},{3,300}};
    int &val = mInt.at(2);
    cout << val;
    return 0;
}

Saída

200

Com o método begin podemos recuperar um iterador que aponta para o primeiro elemento de um Map. Assim, podemos acessar o seu valor.

Sintaxe

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

Onde

iterator: tipo de dado iterador

Retorno

Iterador apontando para o primeiro elemento do Map.

Exemplo 2

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

int main()
{
    map<int,int>  mInt = {{1,100},{2,200},{3,300}};
    map<int,int>::iterator it = mInt.begin();
    cout << "{" << it-> first << "," << it->second << "}";
    return 0;
}

Saída

{1,100}

Com o método clear podemos remover todos os elementos de um Map. Esse método não possui argumentos e nem retorno.

Sintaxe

public void clear() noexcept;

Onde

-

Retorno

-

Exemplo 3

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

int main ()
{
  map<int,int> mInt = {{1,2},{2,3}};
  cout << mInt.size() << endl; //retorna número de elementos
  mInt.clear();
  cout << mInt.size() << endl;
  return 0;
}

Saída

2
0

Para verificar se um Map está vazio, 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 Map está vazia, false caso contrário.

Exemplo 4

#include <iostream>
#include <map>

using namespace std;

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

Saída

false

Com o método end podemos recuperar um iterador que aponta para o fim de um Map. Esse método não recebe argumentos e retorna um itererador.

Sintaxe

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

Onde

-

Retorno

Iterador apontando para o fim do Map.

Exemplo 5

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

int main ()
{
  map<int,int> mInt = {{1,200},{2,300}};
  map<int,int>::iterator it = mInt.end();
  
  it--;
  cout << it->first << endl;
  cout << it->second << endl;
  return 0;
}

Saída

2
300

Para remover um elemento ou intervalo de elementos de uma list, podemos utilizar o método erase que recebe uma posição, ou um intervalo, como argumento para remoção.

Sintaxe

public iterator erase(const_iterator position); //posição até o fim

public size_type erase(const tipo_chave &k); //baseado em chave

public iterator erase(const_iterator first, const_iterator last); //baseado em intervalo

Onde

position:Iterador para a posição de remoção de elemento
k:Chave do elemento para remoção
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 6

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

int main ()
{
  map<int,int> mInt = {{1,200},{2,300},{3,400}};

  mInt.erase(1); //por chave
  
  for ( pair<int,int> p: mInt)
    cout << "{" << p.first << "," << p.second << "}";
  return 0;
}

Saída

{2,300}{3,400}

Utilizando o método find, podemos buscar por elemento contido um Map baseado em uma chave passada como argumento. Esse método retorna um iterador para o elemento encontrado.

Sintaxe

public iterator find(const tipo_chave &k);
const_iterator find(const key_type& k) const;

Onde

k:Chave do elemento para busca.

Retorno

Iterador para elemento representado por k se encontrado, caso contrário retorna iterador para fim(end).

Exemplo 6

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

int main ()
{
    map<int,string> mInt ={};
    
    mInt.insert(pair<int,string>(1,"abc"));
    mInt.insert(pair<int,string>(2,"def"));
    mInt.insert(pair<int,string>(3,"ghi"));
    
    map<int,string>::iterator it = mInt.find(3);
    
    cout<< "{" << it->first << ",\"" << it->second << "\"}" << endl;
  return 0;
}

Saída

{3,400}

O método insert é utilizado para inserir um novo elemento, em uma posição específica ou não, em um Map.

Sintaxe

public pair<iterator, bool> insert(const tipo_chave &val);

template <class P> pair<iterator,bool> insert (P&& val);
iterator insert (const_iterator position, const value_type& val);
template <class P> iterator insert (const_iterator position, P&& val);
template <class InputIterator>  void insert (InputIterator first, InputIterator last);
void insert (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 7

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

int main ()
{
  map<int,int> mInt = {{1,200},{2,300},{3,400}};
  map<int,int>::iterator it = mInt.find(3);
  cout << "{" << it->first << "," << it->second << "}";
  return 0;
}

Saída

3
4
0 1 2 3

O método size retorna o número de elmentos chave-valor contidos em um Map. Esse método não recebe argumentos e retorna um inteiro.

Sintaxe

public size_type size() const noexcept;

Onde

-

Retorno

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

Exemplo 11

#include <iostream>
#include <map>

using namespace std;

int main ()
{
  map mInt = {{1,200},{2,300},{3,400}};
  cout << mInt.size();
  
  return 0;
}

Saída

3

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