Dominando std::map en C++: Guía completa con ejemplos de código

¿Qué es std::map?

En la Biblioteca Estándar de Plantillas (STL) de C++, std::map es un contenedor asociativo que almacena elementos como pares clave-valor. Cada clave es única y el contenedor mantiene automáticamente los elementos ordenados según la función de comparación de la clave (por defecto, std::less). Los valores pueden ser de cualquier tipo y se acceden a través de sus claves correspondientes.

Por qué usar std::map

• Las claves son únicas y se almacenan ordenadas, haciendo que las búsquedas sean rápidas (O(log n)).
• Ideal para escenarios que requieren un array asociativo o diccionario con orden garantizado.
• Implementado internamente como árbol de búsqueda binario balanceado (árbol rojo-negro), proporcionando rendimiento confiable en todas las operaciones.
• Soporta inserción, eliminación y recorrido rápidos.
• API rica que se integra perfectamente con iteradores y algoritmos STL.

Sintaxis

Declare un map con:

std::map<TipoClave, TipoValor> nombreMap;

• TipoClave – el tipo de la clave (debe ser comparable).
• TipoValor – el tipo del valor mapeado.
• nombreMap – el nombre de la variable.

Ejemplo:

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

Tipos miembro

• key_type: Tipo de las claves.
• mapped_type: Tipo de los valores mapeados.
• value_type: std::pair<const key_type, mapped_type>
• iterator: Iterador bidireccional sobre value_type.
• const_iterator, reverse_iterator, const_reverse_iterator
• size_type, difference_type

Funciones integradas

• begin() – iterador al primer elemento.
• end() – iterador pasado al final.
• size() – número de elementos.
• empty() – si el map está vacío.
• insert() – añade un par clave/valor.
• find() – localiza un elemento por clave.
• erase() – elimina elementos por iterador o clave.
• clear() – elimina todos los elementos.
• Otras utilidades como count() y lower_bound() también están disponibles.

Iteración sobre elementos del map

Los iteradores dan control total sobre el orden de recorrido, que siempre está ordenado por clave.

#include <iostream>
#include <string>
#include <map>
using namespace std;
int main() {
    map<int, string> estudiantes;
    estudiantes.insert({200, "Alice"});
    estudiantes.insert({201, "John"});
    cout << "Tamaño del map es: " << estudiantes.size() << endl;
    cout << endl << "Orden por defecto del map:" << endl;
    for (auto it = estudiantes.begin(); it != estudiantes.end(); ++it) {
        cout << it->first << ": " << it->second << endl;
    }
    return 0;
}

Salida:

Inserción de datos en std::map

Use insert() para nuevas entradas; rechaza silenciosamente duplicados. Para sobrescribir una clave 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}); // añade nuevo par
    m.insert({1,8}); // ignorado, clave 1 ya existe
    m.insert_or_assign(1,6); // actualiza clave 1 a valor 6
    cout << "Clave\tElemento\n";
    for (auto& p : m) {
        cout << p.first << '\t' << p.second << '\n';
    }
    return 0;
}

Salida:

Búsqueda en un map

Encontrar una clave es sencillo con find(). Si la clave existe, el iterador devuelto apunta al elemento; de lo contrario se devuelve end().

#include <iostream>
#include <map>
using namespace std;
int main() {
    map<int, string> estudiantes;
    estudiantes.insert({200, "Alice"});
    estudiantes.insert({201, "John"});
    if (auto it = estudiantes.find(201); it != estudiantes.end()) {
        cout << "Clave 201 tiene valor: " << it->second << endl;
    }
    return 0;
}

Salida:

Eliminación de datos de un map

Los elementos pueden eliminarse por clave o por iterador. El método erase() invalida solo iteradores que apuntan al elemento eliminado.

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

Salida:

Resumen

• std::map es un contenedor asociativo ordenado con claves únicas.
• Las claves proporcionan búsqueda eficiente; los valores almacenan los datos asociados.
• Todas las operaciones principales se ejecutan en tiempo logarítmico gracias al árbol rojo-negro subyacente.
• Los iteradores permiten recorrido, inserción, eliminación y consultas de rango.
• Con insert_or_assign(), actualizar valores es sencillo.
• Use find() para comprobaciones rápidas de existencia y acceso directo.
• Las operaciones de borrado pueden dirigirse a elementos individuales o limpiar todo el map.