std::map
Almacenamiento ordenado de pares clave-valor
std::map es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué es std::map?
std::map almacena pares clave-valor ordenados por clave. Cada clave es única, y las búsquedas, inserciones y eliminaciones se ejecutan en tiempo logarítmico.
- Las claves se mantienen en orden ascendente.
- Se basa en un árbol binario de búsqueda equilibrado.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> ages;
ages["Alice"] = 30;
ages["Bob"] = 25;
std::cout << "Alice is " << ages["Alice"] << '\n';
return 0;
}Insertar elementos
Puede insertar elementos mediante operator[], insert() o emplace(). Usar [] con una clave inexistente la crea con un valor predeterminado.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m;
m["one"] = 1;
m.insert({"two", 2});
m.emplace("three", 3);
std::cout << m.size() << " entries\n";
return 0;
}Iteración ordenada
Al iterar un std::map, se visitan las claves en orden ascendente. Cada elemento es un std::pair con .first (clave) y .second (valor).
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m{{"banana", 3}, {"apple", 5}, {"cherry", 1}};
for (const auto& p : m) {
std::cout << p.first << " = " << p.second << '\n';
}
return 0;
}Buscar claves
Use find() para buscar una clave de forma segura. Devuelve un iterador al elemento o end() si no se encuentra.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m{{"x", 10}, {"y", 20}};
auto it = m.find("y");
if (it != m.end()) {
std::cout << "Found y = " << it->second << '\n';
} else {
std::cout << "Not found\n";
}
return 0;
}Comprobar la existencia
Para comprobar si existe una clave sin crearla, use count() (devuelve 0 o 1) o contains() en C++20.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m{{"a", 1}};
std::cout << m.count("a") << '\n';
std::cout << m.count("z") << '\n';
return 0;
}Actualizar valores
Volver a asignar una clave actualiza su valor en el mismo lugar. El mapa conserva un solo valor por clave.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> score;
score["player"] = 10;
score["player"] += 5;
std::cout << score["player"] << '\n';
return 0;
}Eliminar elementos
erase() elimina un elemento por clave o mediante un iterador. Cuando recibe una clave, devuelve el número de elementos eliminados.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m{{"a", 1}, {"b", 2}, {"c", 3}};
m.erase("b");
std::cout << m.size() << " left\n";
for (const auto& p : m) std::cout << p.first << ' ';
std::cout << '\n';
return 0;
}Usar at()
at() devuelve una referencia al valor de una clave y lanza std::out_of_range si falta la clave. A diferencia de [], nunca inserta elementos.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m{{"k", 42}};
std::cout << m.at("k") << '\n';
std::cout << "size: " << m.size() << '\n';
return 0;
}Contar la frecuencia de palabras
Un uso clásico de std::map es contar apariciones. El operador [] inicializa las claves nuevas con el valor predeterminado 0, por lo que ++ funciona directamente.
#include <iostream>
#include <map>
#include <string>
int main() {
std::string words[] = {"cat", "dog", "cat", "bird", "dog", "cat"};
std::map<std::string, int> freq;
for (const auto& w : words) freq[w]++;
for (const auto& p : freq) std::cout << p.first << ": " << p.second << '\n';
return 0;
}Enlaces estructurados
C++17 permite desempaquetar cada par mediante enlaces estructurados, asignando nombres claros a la clave y al valor.
#include <iostream>
#include <map>
int main() {
std::map<std::string, int> m{{"red", 1}, {"green", 2}};
for (const auto& [name, value] : m) {
std::cout << name << " -> " << value << '\n';
}
return 0;
}Comprobar si está vacío
empty() indica si el mapa no contiene elementos y clear() los elimina todos de una vez.
#include <iostream>
#include <map>
int main() {
std::map<int, int> m{{1, 1}, {2, 4}};
std::cout << std::boolalpha << m.empty() << '\n';
m.clear();
std::cout << m.empty() << '\n';
return 0;
}Comprobación rápida
Compruebe su comprensión del orden de std::map.
Resumen
Ha aprendido que std::map:
- almacena claves únicas ordenadas asociadas a valores
- admite
insert,[],find,count,atyerase - itera en orden ascendente de las claves mediante pares que puede desempaquetar con enlaces estructurados
A continuación, verá std::set, que permite almacenar únicamente valores únicos ordenados.
Preguntas frecuentes
¿La lección «std::map» es gratis?
Sí — el texto completo de «std::map» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «std::map»?
Almacenamiento ordenado de pares clave-valor Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «std::map»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.