Clasificación de mapa C ++ por clave

Un mapa consta de pares de clave/valor. Cada par es un elemento. Todas las teclas en un mapa son únicas. Un mapa se puede ordenar por teclas. La clasificación puede ser ascendente o descendente. Ascender es el valor predeterminado. Clasificar en un mapa no siempre es sencillo. Necesita un objeto de función de comparación. Si se ignora el objeto de comparación, se realiza la clasificación predeterminada.

Si las claves son pechos constantes a personajes, el mapa está ordenado por los punteros de la clave, y no por los literales de cadena de la clave. Esto no es lo que nadie quiere. Considere los siguientes pares de llave/valor de frutas y sus colores exteriores:

"ciruela" => "púrpura"
"Blackberry" => "Blue-Black oscuro"
"sandía" => "verde"
"Apricot", => "naranja"
"papaya" => "naranja"
"Banana" => "amarillo"

Las frutas son las teclas, y los colores son los valores. Esta lista de elementos (pares de clave/valor) no está ordenada. El siguiente programa crea un mapa de esta lista tal como está y lo muestra tal como está, sin clasificar por literales de cadena:

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

mapa MP;
MP ["Plum"] = "púrpura";
MP ["Blackberry"] = "Blue Black";
MP ["sandía"] = "verde";
MP ["Apricot"] = "naranja";
MP ["Papaya"] = "naranja";
MP ["Banana"] = "amarillo";
para (mapa:: iterator it = mp.comenzar(); él != MP.fin(); IT ++)
cout << it->primero << " => " << it->segundo << endl;
regresar 0;

La salida es:

Plum => morado
Blackberry => Blue negro oscuro
sandía => verde
albaricoque => naranja
papaya => naranja
plátano => amarillo

no presentado por literales de cuerda, pero ordenado por punteros. Para usar un mapa en un programa C ++, la biblioteca de mapas debe incluirse con una directiva incluir.

Otra forma de crear el mapa simple anterior es la siguiente:

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

mapa mp ("Plum", "púrpura", "Blackberry", "Blue-Black oscuro", "Watermelon", "verde", "albaricoque", "naranja", "papaya" , "naranja", "plátano", "amarillo");
para (mapa:: iterator it = mp.comenzar(); él != MP.fin(); IT ++)
cout << it->primero << " => " << it->segundo << endl;
regresar 0;

La salida es:

Plum => morado
Blackberry => Blue negro oscuro
sandía => verde
albaricoque => naranja
papaya => naranja
plátano => amarillo

no presentado por literales de cuerdas, aunque ordenados por punteros. Si las teclas fueran enteros, la salida habría sido ordenada por teclas. En la práctica, las claves de muchos mapas son literales de cadena. Este artículo explica cómo las teclas de los literales de cadena pueden ordenar un mapa.

Contenido del artículo

• Ordenado durante la creación
• Producir una gama descendente
• Comparando dos elementos por clave
• Clasificación de mapa creado con la lista de inicializador
• Conclusión

Ordenar durante la creación

La plantilla completa para la construcción del mapa es:

plantilla, asignator de clases = asignator>> mapa de clase;

Las clases, comparar y asignador, tienen valores predeterminados. Es decir, tienen especialización predeterminada, que no tiene que ser escrita en las declaraciones de mapa (instancias). Lo que es de interés aquí es la clase de comparación. El nombre de la clase se compara, y la especialización predeterminada es "menor". "menos

Un mapa se crea normalmente ordenado por teclas durante la creación. Si las claves son const char*, entonces los punteros a las cadenas literal citadas serán ordenadas, no los textos literarios. Para tener cadenas como claves ordenadas durante la creación, las cadenas deben ser literales de objetos de cadena instanciados desde la clase de cadena. Esto significa que la biblioteca de cadenas debe incluirse, así como la biblioteca de mapas.

Creando ascendente

En el siguiente programa, se crea el mapa, ascendente ordenado:

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

mapa> mp;
MP ["Plum"] = "púrpura";
MP ["Blackberry"] = "Blue Black";
MP ["sandía"] = "verde";
MP ["Apricot"] = "naranja";
MP ["Papaya"] = "naranja";
MP ["Banana"] = "amarillo";
para (mapa:: iterator it = mp.comenzar(); él != MP.fin(); IT ++)
cout << it->primero << " => " << it->segundo << endl;
regresar 0;

La salida es:

albaricoque => naranja
plátano => amarillo
Blackberry => Blue negro oscuro
papaya => naranja
Plum => morado
sandía => verde

Incluso si se omitieran menos de la plantilla, la clasificación aún habría ascendido porque menos es el valor predeterminado.

Creando descendente

Para crear un mapa, de modo que se ordene en orden descendente por claves, la especialización de comparación debe codificarse. El siguiente programa ilustra esto:

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

mapa> mp;
MP ["Plum"] = "púrpura";
MP ["Blackberry"] = "Blue Black";
MP ["sandía"] = "verde";
MP ["Apricot"] = "naranja";
MP ["Papaya"] = "naranja";
MP ["Banana"] = "amarillo";
para (mapa:: iterator it = mp.comenzar(); él != MP.fin(); IT ++)
cout << it->primero << " => " << it->segundo << endl;
regresar 0;

La salida es:

sandía => verde
Plum => morado
papaya => naranja
Blackberry => Blue negro oscuro
plátano => amarillo
albaricoque => naranja

Producir una gama descendente

Se puede producir una gama de un mapa en orden descendente. Esto implica crear un segundo mapa, que es un rango desde el primer mapa. El siguiente programa ilustra esto:

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

mapa MP;
MP ["Plum"] = "púrpura";
MP ["Blackberry"] = "Blue Black";
MP ["sandía"] = "verde";
MP ["Apricot"] = "naranja";
MP ["Papaya"] = "naranja";
MP ["Banana"] = "amarillo";
mapa:: iterator itb = mp.comenzar();
itb ++;
mapa:: iterator ite = mp.fin();
ite--;
mapa> mpr (itb, ite);
para (mapa:: iterator it = mpr.comenzar(); él != MPR.fin(); IT ++)
cout << it->primero << " => " << it->segundo << endl;
regresar 0;

La salida es:

Plum => morado
papaya => naranja
Blackberry => Blue negro oscuro
plátano => amarillo

El primer objeto de mapa tiene seis elementos que son:

albaricoque => naranja
plátano => amarillo
Blackberry => Blue negro oscuro
papaya => naranja
Plum => morado
sandía => verde

El rango considerado es:

plátano => amarillo
Blackberry => Blue negro oscuro
papaya => naranja
Plum => morado
sandía => verde

En el código, "itb ++" apunta a "plátano", "amarillo" e "ite-" apunta a "sandía", "verde" para el rango. Al manejar un rango en C ++, el elemento final no está involucrado en la manipulación. Y así, la salida tiene cuatro elementos con "sandía", "verde" omitido.

La especialización del parámetro de plantilla de comparación del segundo mapa es mayor. Si fuera menos u omitido, el rango habría resultado en un orden ascendente.

Comparando dos elementos por clave

key_compare key_comp () const

Esta función miembro devuelve una copia del objeto de comparación utilizado por el contenedor de mapas para comparar claves. Un objeto de comparación es un objeto de función. Tomaría dos claves como argumentos y devolvería verdadero si la tecla izquierda es menor que la derecha. Con eso, el segmento de código debería ser:

key_compare kc = mp.key_comp ();
bool bl = kc ("sandía", "albaricoque");

key_compare no es reconocido por el compilador. Eliminar Key_Compare en este segmento de código, sustituyendo KC en la segunda declaración, da como resultado:

bool bl = mp.key_comp () ("sandía", "albaricoque");

El siguiente programa ilustra el uso de key_comp ().

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

mapa MP;
MP ["Plum"] = "púrpura";
MP ["Blackberry"] = "Blue Black";
MP ["sandía"] = "verde";
MP ["Apricot"] = "naranja";
MP ["Papaya"] = "naranja";
MP ["Banana"] = "amarillo";
bool bl = mp.key_comp () ("sandía", "albaricoque");
cout << bl << endl;
regresar 0;

La salida es 0 para falso.

El problema real con el segmento de código anterior es que el espacio de nombres para Key_Compare no estaba bien expresado. Si el segmento era,

mapa:: key_compare kc = mp.key_comp ();
bool bl = kc ("sandía", "albaricoque");

Hubiera funcionado (aceptado por el compilador).

value_compare value_comp () const

Esta función miembro es similar a Key_Comp (). Nota: Aquí, no es el valor del par de clave/valor al que se hace referencia; Es el elemento del par de clave/valor. Entonces, los dos argumentos para el objeto de función Value_Compare son los elementos de iterador. El siguiente programa usa value_comp (), al comparar los primeros elementos y últimos, "albaricoque", "naranja" y "sandía", "verde":

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

mapa> mp;
MP ["Plum"] = "púrpura";
MP ["Blackberry"] = "Blue Black";
MP ["sandía"] = "verde";
MP ["Apricot"] = "naranja";
MP ["Papaya"] = "naranja";
MP ["Banana"] = "amarillo";
mapa:: iterator itb = mp.comenzar();
mapa:: iterator ite = mp.fin();
ite--;
mapa:: value_compare vc = mp.value_comp ();
bool bl = vc ( *itb, *ite);
cout << bl << endl;
regresar 0;

La salida es 1, para verdadero. Los iteradores ITB e Ite fueron desactivos para tener sus elementos, con el operador de indirección.

Clasificación de mapa creado con la lista de inicializador

En el siguiente programa, donde la clasificación desciende, las teclas son objetos de cadena, instanciadas desde la clase de cadena:

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

mapa> mp ("Plum", "púrpura", "Blackberry", "Blue-Black oscuro", "Watermelon", "verde", "albaricoque", "naranja", "papaya "," naranja ", " plátano "," amarillo ");
para (mapa:: iterator it = mp.comenzar(); él != MP.fin(); IT ++)
cout << it->primero << " => " << it->segundo << endl;
regresar 0;

La salida es:

sandía => verde
Plum => morado
papaya => naranja
Blackberry => Blue negro oscuro
plátano => amarillo
albaricoque => naranja

Conclusión

Se crea un mapa ordenado por teclas, ascendente. Ascender es el orden predeterminado. Para que descienda, agregue la especialización de parámetros de plantilla, mayor como el tercer argumento, en la lista de argumentos de plantilla. Nota: Si las teclas son cadenas, deben instanciarse desde la clase de cadena, como se ilustra arriba. Las teclas de cadena como const-Char* o char-arr [], terminan con sus punteros ordenados y no con sus literales.