Idioma: ES
LuisLlamas Logo
Buscar
⏲️ ~ 6 minutos Intermedio
cpp-que-son-maps

Qué son y cómo usar los diccionarios en C++

Un Map es una colección que almacena pares clave-valor. Permiten realizar búsquedas, inserciones y eliminaciones de manera eficiente.

La clase std::map de la biblioteca estándar de C++ es la implementación de esta estructura de datos.

Las claves en un std::map deben ser únicas y se utilizan para acceder a los valores correspondientes.

Si quieres aprender más sobre Diccionarios
consulta el Curso de Introducción a la Programación leer más

Declaración de maps

Para declarar un map en C++, se utiliza la siguiente sintaxis:

#include <map>

std::map<tipoClave, tipoValor> nombremap;
  • tipoClave: Es el tipo de datos de las claves.
  • tipoValor: Es el tipo de datos de los valores.
  • nombremap: Es el identificador del map.

Por ejemplo, si queremos crear un map que almacene nombres de personas y sus edades, podemos usar la siguiente sintaxis:

#include <map>
#include <string>

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

Inicialización de un map

Una vez declarado el map, debemos inicializarlo antes de usarlo. Aquí te mostramos cómo hacerlo:

Puedes crear un map vacío y luego agregarle elementos:

std::map<std::string, int> edades; // map vacío

También puedes inicializar un map con valores específicos utilizando la lista de inicialización:

std::map<std::string, int> edades = {
    {"Luis", 25},
    {"María", 30},
    {"Pedro", 28}
};

Uso básico del map

Añadir elementos a un map

Para añadir elementos a un map, puedes usar el operador de índice [] o el método insert:

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

edades["Luis"] = 32; // Usando el operador de índice
edades.insert({"Ana", 22}); // Usando el método insert

Acceder a elementos de un map

Los elementos de un map se pueden acceder mediante sus claves:

std::map<std::string, int> edades = {
    {"Luis", 25},
    {"María", 30}
};

int edadDeLuis = edades["Luis"];
std::cout << "La edad de Luis es: " << edadDeLuis << std::endl;

Alternativamente podemos usar el método at, que proporciona acceso seguro a los elementos (lanzando una excepción si la clave no existe).

int segundo_elemento = edades.at(1);

Modificar elementos de un map

Para modificar el valor asociado a una clave existente, simplemente asigna un nuevo valor a esa clave:

std::map<std::string, int> edades = {
    {"María", 30}
};

edades["María"] = 35; // Modificando el valor
std::cout << "La edad de María actualizada es: " << edades["María"] << std::endl;

Eliminar elementos de un map

Para eliminar un elemento del map, utiliza el método erase:

std::map<std::string, int> edades = {
    {"Pedro", 28}
};

edades.erase("Pedro"); // Elimina el elemento con clave "Pedro"

Enumerar elementos en un map

Para recorrer todos los elementos de un map, puedes usar un bucle for con iteradores:

std::map<std::string, int> edades = {
    {"Luis", 25},
    {"María", 30}
};

for (const auto& item : edades) {
    std::cout << "Nombre: " << item.first << ", Edad: " << item.second << std::endl;
}

Limpiar todo el map

Para eliminar todos los elementos del map, usa el método clear:

edades.clear(); // Elimina todos los elementos del map

Propiedades y métodos útiles

Método size

La función size() devuelve el número de pares clave-valor en el map:

std::cout << "Número de elementos en el map: " << edades.size() << std::endl;

Método find

El método find busca una clave específica y devuelve un iterador a la posición encontrada o end si la clave no está en el map:

auto it = edades.find("Luis");
if (it != edades.end()) {
    std::cout << "La edad de Luis es: " << it->second << std::endl;
} else {
    std::cout << "Luis no está en el map." << std::endl;
}

Método count

El método count verifica si una clave específica está presente en el map:

bool contieneLuis = edades.count("Luis") > 0;
std::cout << "¿Contiene a Luis?: " << (contieneLuis ? "Sí" : "No") << std::endl;

Método clear

El método clear elimina todos los elementos del map:

edades.clear(); // Elimina todos los elementos

Método empty

Comprueba si el mapa está vacío.

bool esta_vacio = edades.empty();

Metodos lower_bound y upper_bound

Devuelven iteradores al primer elemento no menor y al primer elemento mayor que una clave específica, respectivamente.

auto it_lower = estudiantes.lower_bound(2);
auto it_upper = estudiantes.upper_bound(2);

Ejemplos prácticos

Almacenar información de estudiantes y sus calificaciones

En este ejemplo, mostramos cómo almacenar las calificaciones de varios estudiantes en un map y calcular el promedio de cada uno.

#include <map>
#include <string>
#include <vector>
#include <iostream>
#include <numeric>

int main() {
    // Crear un map para almacenar las calificaciones de los estudiantes
    std::map<std::string, std::vector<int>> calificacionesEstudiantes;

    // Agregar calificaciones para cada estudiante
    calificacionesEstudiantes["Luis"] = {90, 85, 88};
    calificacionesEstudiantes["María"] = {95, 92, 89};
    calificacionesEstudiantes["Pedro"] = {78, 84, 80};

    // Iterar sobre el map y calcular el promedio de cada estudiante
    for (const auto& alumno : calificacionesEstudiantes) {
        std::string nombre = alumno.first; // Nombre del estudiante
        const auto& calificaciones = alumno.second; // Lista de calificaciones del estudiante
        double promedio = std::accumulate(calificaciones.begin(), calificaciones.end(), 0.0) / calificaciones.size(); // Calcular el promedio

        std::cout << "Estudiante: " << nombre << ", Promedio: " << promedio << std::endl;
    }

    return 0;
}
Buscar el precio de un producto específico

En este ejemplo, mostramos cómo buscar el precio de un producto específico utilizando un map.

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

int main() {
    // Crear un map para almacenar los precios de los productos
    std::map<std::string, double> preciosProductos;

    // Agregar precios para cada producto
    preciosProductos["Manzana"] = 1.2;
    preciosProductos["Banana"] = 0.5;
    preciosProductos["Naranja"] = 0.8;

    // Buscar el precio de un producto específico
    std::string productoBuscar = "Banana";
    auto it = preciosProductos.find(productoBuscar);
    if (it != preciosProductos.end())

 {
        std::cout << "Producto: " << productoBuscar << ", Precio: " << it->second << std::endl;
    } else {
        std::cout << "El producto " << productoBuscar << " no se encuentra en el map." << std::endl;
    }

    return 0;
}
Buscar el departamento de una lista de empleados

En este ejemplo, utilizamos un map para realizar búsquedas rápidas de los departamentos de empleados.

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

int main() {
    // Crear un map para almacenar los departamentos de los empleados
    std::map<std::string, std::string> departamentosEmpleados = {
        {"Ana", "Ventas"},
        {"Luis", "Finanzas"},
        {"Carlos", "TI"},
        {"Pedro", "Recursos Humanos"},
        {"María", "Marketing"}
    };

    // Lista de empleados a buscar
    std::vector<std::string> empleadosABuscar = {"Ana", "Luis", "Carlos", "Pedro", "María"};

    // Realizar búsquedas rápidas
    for (const std::string& empleadoBuscar : empleadosABuscar) {
        auto it = departamentosEmpleados.find(empleadoBuscar);
        if (it != departamentosEmpleados.end()) {
            std::cout << "Empleado: " << empleadoBuscar << ", Departamento: " << it->second << std::endl;
        } else {
            std::cout << "El empleado " << empleadoBuscar << " no se encuentra en el map." << std::endl;
        }
    }

    return 0;
}

En esta página