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.

Declaración e inicialización de mapas

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

#include <map>

std::map<tipoClave, tipoValor> nombreMapa;

Donde:

• tipoClave: Es el tipo de datos de las claves.
• tipoValor: Es el tipo de datos de los valores.
• nombreMapa: Es el identificador del mapa.

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

#include <map>
#include <string>

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

Creación e Inicialización de un Mapa

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

Inicialización Vacía

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

#include <map>
#include <string>

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

Inicialización con Valores

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

#include <map>
#include <string>

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

Uso básico del mapa

Añadir elementos a un mapa

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

#include <map>
#include <string>

int main() {
    std::map<std::string, int> edades;

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

    return 0;
}

Acceder a elementos de un mapa

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

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

int main() {
    std::map<std::string, int> edades = {
        {"Juan", 25},
        {"María", 30}
    };

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

    return 0;
}

Modificar elementos de un mapa

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

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

int main() {
    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;

    return 0;
}

Eliminar elementos de un mapa

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

#include <map>
#include <string>

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

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

    return 0;
}

Enumerar elementos en un mapa

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

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

int main() {
    std::map<std::string, int> edades = {
        {"Juan", 25},
        {"María", 30}
    };

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

    return 0;
}

Limpiar todo el mapa

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

#include <map>
#include <string>

int main() {
    std::map<std::string, int> edades = {
        {"Juan", 25},
        {"María", 30}
    };

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

    return 0;
}

Propiedades y Métodos Útiles de std::map

Método Size

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

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

int main() {
    std::map<std::string, int> edades = {
        {"Juan", 25},
        {"María", 30}
    };

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

    return 0;
}

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 mapa:

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

int main() {
    std::map<std::string, int> edades = {
        {"Juan", 25}
    };

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

    return 0;
}

Método Count

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

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

int main() {
    std::map<std::string, int> edades = {
        {"Juan", 25}
    };

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

    return 0;
}

Método Clear

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

#include <map>
#include <string>

int main() {
    std::map<std::string, int> edades = {
        {"Juan", 25}
    };

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

    return 0;
}

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 mapa y calcular el promedio de cada uno.

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

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

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

    // Iterar sobre el mapa 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 mapa.

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

int main() {
    // Crear un mapa 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 mapa." << std::endl;
    }

    return 0;
}

Buscar el Departamento de una Lista de Empleados

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

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

int main() {
    // Crear un mapa 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 mapa." << std::endl;
        }
    }

    return 0;
}