Cómo usar mapas en C ++

El mapa C ++ es una estructura de datos de lista con pares de clave/valor. Una estructura de datos tiene funciones miembros. En C ++, hay un mapa, y hay un_map sin ordenad. El mapa es en realidad un mapa ordenado. El orden para el mapa puede ser ascendente o descendente por teclas. El valor predeterminado es el orden ascendente por claves. Las características para el mapa ordenado y el mapa desordenado son tantos en la medida en que solo las del mapa (i.mi., mapa ordenado) se considerará en este artículo.

Las características del mapa se pueden clasificar en construcción, acceso de elementos, capacidad, iteradores, modificadores, observadores, operaciones y algoritmos especializados. También sucede que las características del mapa son muchas. Entonces, solo se explicarán las funciones básicas en estas categorías.

Un ejemplo de una lista de pares de clave/valor es la siguiente lista de frutas y sus colores comunes de piel madura:

Blackberry => Blue negro oscuro
mango => amarillo
Fruta de la pasión => morado
Plum => morado
plátano => amarillo

Las cadenas a la izquierda de la lista forman las claves; aquellos en la forma correcta los valores. Los pares de clave/valor no deben ser necesariamente de cadena/cadena. Puede ser de int/string, string/float, int/float, etc. En un mapa C ++, un par de clave/valor es un elemento, y tales elementos forman la lista de estructuras de datos. Una estructura de datos del mapa proporciona una recuperación rápida de datos basados ​​en claves. Las teclas son únicas y la estructura del mapa es muchos a uno. Esto significa que los valores pueden tener duplicados, pero las claves no pueden.

Para usar la biblioteca de mapas en un programa C ++, el programa debe comenzar con algo como:

#incluir
#incluir
usando el espacio de nombres STD;

Si las cadenas son parte del mapa, se aconsejará usar #include en lugar de. Este artículo explica cómo usar un mapa C ++.

Contenido del artículo

• Construcción/destrucción
• Construcción y ajuste de pares
• Mostrar (impresión) Contenido del mapa
• Acceso al elemento
• Capacidad
• Iteradores
• Modificadores
• Ordenación ascendente o descendente
• Operaciones
• Algoritmos especializados
• Conclusión

Construcción/destrucción

Un mapa es un contenedor asociativo que debe construirse a partir de una clase de mapa.

Mapa (Initializer_list, const compare & = compare (), const alcator & = allocator ())

La siguiente declaración construye un mapa para la lista anterior por inicialización:

mapa MP "Blackberry", "Blue Blue oscuro", "mango", "amarillo", "pasión fruta", "púrpura", "ciruela", "púrpura", "plátano" , "amarillo";

Tenga en cuenta cómo ha sido demarcado cada par.

a = IL

La siguiente construcción de inicialización utiliza el operador de asignación:

mapa mp = "Blackberry", "Blue azul oscuro", "mango", "amarillo", "fruta de pasión", "púrpura", "ciruela", "púrpura", "plátano ", "amarillo";

Se puede crear un mapa vacío con la expresión de la izquierda, y luego los elementos agregados más tarde; consulte a continuación.

Destrucción
Para destruir un mapa, solo déjelo salir del alcance.

Construcción y ajuste de pares

Para el mapa anterior, un par consiste en una tecla de cadena y un valor de cadena. Un elemento de par se puede construir independientemente del mapa. El siguiente segmento de código crea un objeto de par vacío a partir de una clase de par y luego asigna una clave y un valor:

par de PR;
PRS.Primero = "BlackBerry";
PRS.segundo = "azul oscuro-negro";

El nombre de la propiedad clave es el primero, y el nombre de la propiedad de valor es el segundo. El siguiente código crea un mapa vacío e inserta dos pares usando la función de miembro insertar mapa.

mapa mp;
par de pr0;
PR0.Primero = "BlackBerry";
PR0.segundo = "azul oscuro-negro";
Par de PR1;
PR1.primero = "mango";
PR1.segundo = "amarillo";
diputado.insertar (pr0);
diputado.insertar (PR1);

Mostrar (impresión) Contenido del mapa

El siguiente código utiliza un iterador (IT), desarrollado desde el primer elemento del mapa, para mostrar los pares de teclas/valor, en la consola:

MAP mp = "Plum", "púrpura", "mango", "amarillo", "Blackberry", "Blue-Black oscuro", "Fruta de pasión", "púrpura", " plátano "," amarillo ";
para (map :: iterator it = mp.comenzar(); él!= MP.fin(); ++ it)
cout Blackberry => Blue negro oscuro
mango => amarillo
Fruta de la pasión => morado
Plum => morado

=> no tiene importancia de C ++ aquí. Se solo usa para separar la clave de su valor correspondiente en la pantalla. Para obtener el valor de una propiedad de un puntero (iterador), use -> entre el puntero (iterador) y el nombre de la propiedad. Entonces, -> tiene importancia en C++.

Tenga en cuenta que la lista se ha mostrado en orden ascendente de claves, aunque los elementos no fueron codificados.

Aún se puede acceder a los pares de clave/valor utilizando el esquema para el elemento en la lista. El siguiente segmento de código ilustra esto:

MAP mp = "Plum", "púrpura", "mango", "amarillo", "Blackberry", "Blue-Black oscuro", "Fruta de pasión", "púrpura", " plátano "," amarillo ";
para (par elem: mp)
cout << elem.first < " << elem.second < yellow
Blackberry => Blue negro oscuro
mango => amarillo
Fruta de la pasión => morado
Plum => morado

Como antes. Tenga en cuenta que elem aquí es un nombre de objeto y no un puntero (ni iterador). Entonces, es seguido por un punto y no -> para acceder a la propiedad.

Acceso al elemento

T & operator [] (key_type && x)

Se puede incluir un elemento que no en el mapa antes se puede incluir usando su clave a través del operador []. El valor de un elemento, que ya está en el mapa, se puede leer a través del operador [] utilizando su clave. El siguiente programa ilustra estos:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

mapa mp;
MP ["Plum"] = "púrpura";
MP ["Passion Fruit"] = "Purple";
MP ["Blackberry"] = "Blue Black";
cout<cout<cout<regresar 0;

La salida es:

púrpura
púrpura
azul oscuro-negro

const t & at (const key_type & x) const

Si el mapa se declara constante, entonces los valores de las teclas no se pueden cambiar. Sin embargo, esta función miembro se puede usar para leer los valores de las teclas. El siguiente código ilustra esto:

const map mp "Plum", "púrpura", "mango", "amarillo", "Blackberry", "Blue-Black oscuro";
cout<cout<cout<

La salida es:

púrpura
amarillo
azul oscuro-negro

Capacidad

size_type size () const noexcept

La longitud de un mapa se puede determinar utilizando la función de miembro size (), como muestra el siguiente código:

const map mp "Plum", "púrpura", "mango", "amarillo", "Blackberry", "Blue-Black oscuro";
cout<

La salida es 3.

[[[nodiscard]] bool vacía () const noexcept

Esta función de miembro devuelve verdadero si el mapa está vacío y falso de lo contrario. Ejemplo:

const map mp;
cout<

La salida es 1 para verdadero. Habría sido 0 para falso (de lo contrario).

Iteradores

iterador begin () noexcept

Esto devuelve un iterador bidireccional que apunta al primer elemento del mapa. El valor del elemento (par) apunta, se puede cambiar. Código de ejemplo:

map mp "Plum", "púrpura", "mango", "amarillo", "Blackberry", "Blue-Black oscuro";
mapa :: iterador it;
para (it = mp.comenzar(); él!= MP.fin(); it ++)
cout
coutpara (map :: iterator it = mp.comenzar(); él!= MP.fin(); it ++)
cout mango => amarillo
Plum => morado
Blackberry => Blue negro oscuro
mango => blanco
Plum => morado

Se cambió el valor para el segundo par de la clave/valor. Tenga en cuenta el uso del iterador final ().

reverse_iterator rbegin () Noexcept

Esto devuelve un iterador inverso bidireccional, señalando el último elemento del mapa. El valor del elemento al que señala se puede cambiar. El siguiente código produce el mismo resultado que el anterior:

map mp "Plum", "púrpura", "mango", "amarillo", "Blackberry", "Blue-Black oscuro";
mapa :: reverse_iterator it;
para (it = mp.rbegin (); él!= MP.desgarrar(); it ++)
cout
coutpara (map :: reverse_iterator it = mp.rbegin (); él!= MP.desgarrar(); it ++)
cout mango => amarillo
Blackberry => Blue negro oscuro
Plum => morado
mango => blanco
Blackberry => Blue negro oscuro

Se ha cambiado el mismo valor para el segundo par de la clave/valor.

Modificadores

Con el mapa, ya que siempre estará organizado (ordenado) por claves, después de insertar, no importa si la inserción es dirigida por el programador al principio, dentro o al final del mapa. El orden ascendente por claves es el resultado predeterminado.

Modificar el mapa se ocupa de la inserción, emplatamiento, extracción, borrado y limpieza. Insertar y emplace son similares, pero el emplace es mejor.

Emplárgico

par a_uniq.Emplace (args)

Esta función miembro inserta los literales del par de clave/valor, separados por coma, sin los soportes rizados, como se muestra en el siguiente código:

map mp = "BlackBerry", "Blue-Black oscuro", "mango", "amarillo", "Fruta de pasión", "púrpura";
par PR = MP.Emplace ("plátano", "amarillo");
Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout Blackberry => Blue negro oscuro
mango => amarillo
Fruta de la pasión => morado
Banana => 1

La función miembro emplace (args) devuelve un par correspondiente al elemento insertado. La clave de este par de retorno es un iterador que apunta al elemento insertado. El valor de este par de retorno es verdadero (1) si se produjo la inserción y falsa (0) si la inserción no tuvo lugar.

Tenga en cuenta la forma en que se ha codificado el tipo de retorno para Emplace (args). Además, el par de retorno no se ha utilizado para obtener la clave/valor del par de mapas insertado en la última declaración de salida. Aquí hay dos tipos de pares: el par para el mapa y el par de retorno. No son compatibles. Si la clave ya existiera en el mapa, el iterador devuelto apuntaría a la clave que existía; Entonces, el valor booleano sería falso.

Inserción

par insertar (value_type && x)

Esta función miembro inserta los literales del par de clave/valor, separados por coma, con los soportes rizados, como se muestra en el siguiente código:

map mp = "BlackBerry", "Blue-Black oscuro", "mango", "amarillo", "Fruta de pasión", "púrpura";
par PR = MP.insert ("plátano", "amarillo");
Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout Blackberry => Blue negro oscuro
mango => amarillo
Fruta de la pasión => morado
Banana => 1

La explicación es similar en el caso anterior para Emplace (args).

par insertar (const valle_type & x)

El identificador de un par se puede usar como argumento a la función insert (). Ilustración:

map mp = "BlackBerry", "Blue-Black oscuro", "mango", "amarillo", "Fruta de pasión", "púrpura";
par de PR;
PRS.primero = "plátano";
PRS.segundo = "amarillo";
par IB = MP.insertar (pr);
Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout Blackberry => Blue negro oscuro
mango => amarillo
Fruta de la pasión => morado
Banana => 1

La explicación es similar al caso anterior.

Inserto vacío (inicializador_list)

Se puede insertar una lista completa. Inmediatamente después de la inserción, hay reordenamiento (en orden ascendente). Ilustración:

map mp = "BlackBerry", "Blue-Black oscuro", "mango", "amarillo", "Fruta de pasión", "púrpura";
diputado.insertar ("sandía", "verde", "uva", "rosa", "albaricoque", "naranja");
Para (Auto Elem: MP)
cout << elem.first < " << elem.second < orange
Blackberry => Blue negro oscuro
uva => rosa
mango => amarillo
Fruta de la pasión => morado
sandía => verde

NOTA: No debería existir ninguna clave de la lista en el mapa.

Inserto vacío (Inputiterator primero, Inputiterator Last)

Se puede insertar un rango, [i, j) de otro mapa. Aquí, yo y J somos iteradores. Ilustración:

mapa mp1 = "uva", "rosa", "albaricoque", "naranja", "fresa", "rojo", "durazno", "amarillo oscuro", "papaya", "naranja";
mapa :: iterator itb = mp1.comenzar();
itb ++;
mapa :: iterator ite = mp1.fin();
ite--; ite--;
map mp2 = "Blackberry", "Blue-Black oscuro", "mango", "amarillo", "pasión fruta", "púrpura";
mp2.insertar (itb, ite);
Para (Auto Elem: MP2)
cout << elem.first < " << elem.second < dark blue-black
uva => rosa
mango => amarillo
papaya => naranja
Fruta de la pasión => morado

Tenga en cuenta que el elemento correspondiente a J del primer mapa no fue insertado. Esto está de acuerdo con la notación, [i, j).

Borde

size_type Erase (const key_type & x)

Borra el elemento identificado por clave y devuelve el número de elementos borrados (debe ser 1 en el caso de no multimap). Ilustración:

map mp = "BlackBerry", "Blue-Black oscuro", "mango", "amarillo", "Fruta de pasión", "púrpura";
int n = mp.borrar ("mango");
cout<Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<Fruta de la pasión => morado
2

Se elimina el elemento borrado, en lo que respecta al usuario. Entonces el número de elementos se reduce.

Borras de iterador (posición const_iterator)

Borrar se puede hacer usando un iterador. Devuelve un iterador que apunta al elemento después del borrado. Ilustración:

map mp = "BlackBerry", "Blue-Black oscuro", "mango", "amarillo", "Fruta de pasión", "púrpura";
mapa :: iterator it = mp.comenzar();
it ++;
mapa :: iterator iter = mp.Bórralo);
cout Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<Blackberry => Blue negro oscuro
Fruta de la pasión => morado
2

ERASE ITERATOR (const_iterator primero, const_iterator Último)

Esto usa iteradores para borrar un rango del mapa ordenado. Devuelve un iterador que apunta al elemento después del rango borrado. Ilustración:

map mp = "uva", "rosa", "albaricoque", "naranja", "fresa", "rojo", "durazno", "amarillo oscuro", "papaya", "naranja";
Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mapa :: iterator itb = mp.comenzar();
itb ++;
mapa :: iterator ite = mp.fin();
ite--; ite--;
mapa :: iterator iter = mp.borrar (itb, ite);
cout Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<uva => rosa
papaya => naranja
Peach => amarillo oscuro
fresa => rojo
Peach => amarillo oscuro
albaricoque => naranja
Peach => amarillo oscuro
fresa => rojo
3

El pedido del contenido original del mapa se muestra por primera vez en la salida para que se pueda apreciar el rango borrado. Tenga en cuenta que el elemento señalado por el segundo argumento iterador no se borra.

Claro

nulo claro () noexcept

Borra todos los elementos del mapa, haciendo el tamaño del mapa, cero. Ejemplo:

map mp = "uva", "rosa", "albaricoque", "naranja", "fresa", "rojo";
diputado.claro();
cout<

La salida es 0.

Extracción
Esto trata con Node_Type - Ver más tarde.

Fusión
Cuando se fusionan dos mapas, los elementos se entremezclan en orden (ascendente); Ningún par de clave/valor está separado.

Void a.fusionar (A2)

Un elemento en A2 con la misma clave en A no se extrae. Esto trata con Node_Type - Ver más tarde.

Ordenación ascendente o descendente

Por defecto, un mapa se vuelve ascendente por claves justo después de la creación. Se puede hacer descender. En los soportes de ángulo de plantilla, el tercer parámetro tiene el tipo predeterminado, menos. Y así, no tiene que ser escrito. Para hacer que el mapa descendiera por clave, se debe utilizar mayor, como en el siguiente código:

mapa mp = "uva", "rosa", "albaricoque", "naranja", "fresa", "rojo";
Para (Auto Elem: MP)
cout << elem.first < " << elem.second < red
uva => rosa
albaricoque => naranja

Tan pronto como se crea un mapa, se ordena ascender o descender (ascendiendo por defecto). menos o mayor se conoce como un objeto de comparación.

Operaciones

iterator Find (const key_type & x)

Devuelve el iterador del elemento cuya clave es el argumento para encontrar (). Ilustración:

mapa mp = "uva", "rosa", "albaricoque", "naranja", "fresa", "rojo";
mapa :: iterator it = mp.encontrar ("uva");
cout

iterator Lower_bound (const key_type & x)

En un mapa, los elementos están organizados por clave, en orden ascendente, por defecto. Si el programador quiere conocer al iterador que apunta al elemento que no es más bajo que el de una clave en particular, tiene que usar esta función miembro. Ilustración:

map mp = "uva", "rosa", "albaricoque", "naranja", "fresa", "rojo", "durazno", "amarillo oscuro", "papaya", "naranja";
Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mapa :: iterator it = mp.Lower_bound ("Papaya");
cout uva => rosa
papaya => naranja
Peach => amarillo oscuro
fresa => rojo
papaya => naranja

En esta situación, el iterador apunta al elemento clave. Si no se encuentra la clave, la función devolverá a un iterador que apunta justo después del final del mapa. En esta situación, es cíclico, y sería el primer elemento del mapa.

iterador superior_bound (const key_type & x)

Si el programador quiere conocer el iterador que apunta al elemento con la clave mayor que K, tiene que usar esta función miembro. Ilustración:

map mp = "uva", "rosa", "albaricoque", "naranja", "fresa", "rojo", "durazno", "amarillo oscuro", "papaya", "naranja";
Para (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mapa :: iterator it = mp.superior_bound ("papaya");
cout uva => rosa
papaya => naranja
Peach => amarillo oscuro
fresa => rojo
Peach => amarillo oscuro

Un iterador que apunta al elemento justo después de que se devuelva el elemento con llave. Si la clave es para el último elemento, se debe lanzar una excepción. Si la clave no existe, el resultado no es confiable.

Algoritmos especializados

La siguiente es la sintaxis de una función de algoritmo especializada:

plantilla
Swap void (map & x, map e y) noexcept (noexcept (x.intercambio (y)));

En su lugar, se puede usar la siguiente sintaxis:

Swap nulo (mapa y)

Esto cambia los pares de los dos mapas, que no tienen que ser del mismo tamaño. Ejemplo:

map mp1 = "Plum", "púrpura", "mango", "amarillo", "Blackberry", "Blue-Black oscuro", "Fruta de pasión", "púrpura", " plátano "," amarillo ";
map mp2 = "satermelon", "verde", "uva", "rosa", "albaricoque", "naranja", "strawberry", "rojo", "durazno", ",", " amarillo oscuro ", " papaya "," naranja ";
MP1.intercambio (mp2);
cout << "New mp1:" << endl;
Para (Auto Elem: MP1)
cout << elem.first < " << elem.second << endl;
cout<cout << "New mp2:" << endl;
Para (Auto Elem: MP2)
cout << elem.first < " << elem.second << endl;

Conclusión

Un mapa consta de pares de clave/valor. Se ordena por claves, ya sea ascendentes o descendentes. El orden predeterminado es ascender. Funciones de miembro básico para el mapa: map (), operador [], at (), size (), vacía (), begin (), end (), rbegin (), rend (), emplace (), insert () , ERASE (), Clear (), Find (), Lower_Bound (), Upper_Bound () y A1SWAP (A2).