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 .

template< class Iter, class NodeType >
struct /* unspecified */
{
    Iter     position;
    bool     inserted;
    NodeType node;
};

#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