std:: map

std::map es un contenedor asociativo ordenado que contiene pares clave-valor con claves únicas. Las claves se ordenan utilizando la función de comparación Compare . Las operaciones de búsqueda, eliminación e inserción tienen complejidad logarítmica. Los mapas generalmente se implementan como Red–black trees .

Los iteradores de std::map iteran en orden ascendente de claves, donde ascendente se define por la comparación que se utilizó para la construcción. Es decir, dado

• m , un std::map
• it_l y it_r , iteradores dereferenciables a m , con it_l < it_r .

m. value_comp ( ) ( * it_l, * it_r ) == true (de menor a mayor si se utiliza la comparación por defecto).

En todas partes donde la biblioteca estándar utiliza los Compare requisitos, la unicidad se determina utilizando la relación de equivalencia. En términos imprecisos, dos objetos a y b se consideran equivalentes (no únicos) si ninguno es menor que el otro: ! comp ( a, b ) && ! comp ( b, a ) .

std::map cumple con los requisitos de Container , AllocatorAwareContainer , AssociativeContainer y ReversibleContainer .

Parámetros de plantilla

Tipos de miembros

Clases miembro

Funciones miembro

Funciones no miembro

Notas

Ejemplo

#include <iostream>
#include <map>
#include <string>
#include <string_view>
void print_map(std::string_view comment, const std::map<std::string, int>& m)
{
    std::cout << comment;
    // Iterar usando facilidades de C++17
    for (const auto& [key, value] : m)
        std::cout << '[' << key << "] = " << value << "; ";
// Alternativa C++11:
//  for (const auto& n : m)
//      std::cout << n.first << " = " << n.second << "; ";
//
// Alternativa C++98:
//  for (std::map<std::string, int>::const_iterator it = m.begin(); it != m.end(); ++it)
//      std::cout << it->first << " = " << it->second << "; ";
    std::cout << '\n';
}
int main()
{
    // Crear un mapa de tres pares (string, int)
    std::map<std::string, int> m{{"CPU", 10}, {"GPU", 15}, {"RAM", 20}};
    print_map("1) Mapa inicial: ", m);
    m["CPU"] = 25; // actualizar un valor existente
    m["SSD"] = 30; // insertar un nuevo valor
    print_map("2) Mapa actualizado: ", m);
    // Usar operator[] con una clave inexistente siempre realiza una inserción
    std::cout << "3) m[UPS] = " << m["UPS"] << '\n';
    print_map("4) Mapa actualizado: ", m);
    m.erase("GPU");
    print_map("5) Después de borrar: ", m);
    std::erase_if(m, [](const auto& pair){ return pair.second > 25; });
    print_map("6) Después de borrar: ", m);
    std::cout << "7) m.size() = " << m.size() << '\n';
    m.clear();
    std::cout << std::boolalpha << "8) Mapa vacío: " << m.empty() << '\n';
}

1) Mapa inicial: [CPU] = 10; [GPU] = 15; [RAM] = 20;
2) Mapa actualizado: [CPU] = 25; [GPU] = 15; [RAM] = 20; [SSD] = 30;
3) m[UPS] = 0
4) Mapa actualizado: [CPU] = 25; [GPU] = 15; [RAM] = 20; [SSD] = 30; [UPS] = 0;
5) Después de borrar: [CPU] = 25; [RAM] = 20; [SSD] = 30; [UPS] = 0;
6) Después de borrar: [CPU] = 25; [RAM] = 20; [UPS] = 0;
7) m.size() = 3
8) Mapa vacío: true

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también