Comparador de mapas C ++

Un mapa es una estructura de lista de elementos. Cada elemento es un par de clave/valor, y las claves son únicas. Un mapa se puede ordenar por teclas de más pequeño a más grande. En un tipo, una clave se mueve con su valor correspondiente. La clasificación en orden ascendente como este utiliza el comparador de mapas de la forma, menos que ().

El siguiente código clasifica un mapa de teclas en orden ascendente, durante la creación del mapa:

mapa> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
para (mapa:: iterator ite = mp.comenzar(); ite != MP.fin(); ite ++)
cout << ite->primero << " => " << ite->segundo << endl;

La salida es:

M => 4
N => 2
O => 5
P => 1
Q => 3

El código real para el comparador aquí es "menos", en la especialización de la plantilla de mapa. El siguiente código clasifica un mapa de teclas en orden descendente, durante la creación del mapa:

mapa> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
para (mapa:: iterator ite = mp.comenzar(); ite != MP.fin(); ite ++)
cout << ite->primero << " => " << ite->segundo << endl;

La salida es:

Q => 3
P => 1
O => 5
N => 2
M => 4

El código real para el comparador aquí es "mayor" en la especialización de la plantilla de mapa.

Para las muestras de código anteriores, la biblioteca de mapas se incluye en el programa. El formulario de comparación predeterminado es menos. Por lo tanto, podría haberse omitido en el código anterior para tener,

mapa diputado

Para la especialización de la plantilla del mapa.

Si el programador no está satisfecho con el comparador ofrecido por C ++, el programador puede escribir el suyo propio. Este artículo explica cómo el programador puede aplicar su propio comparador al mapa. La comparación normal de las teclas de cadena es sensible a la caja. Se utiliza el ejemplo de comparación insensible a los casos.

Contenido del artículo

• Comparación normal de las teclas de cadena
• Operador de comparación insensible de estuche personalizado
• Especialización de plantilla de comparación
• Función principal para un comparador personalizado
• Conclusión

Comparación normal de las teclas de cadena

Considere una clase de cinco estudiantes, para un mapa de nombres contra marcas, en una prueba, como sigue:

María => 70
John => 60
Susan => 50
Paul => 45
Joseph => 75

Un mapa C ++ para el comparador predeterminado, menos está en el programa:

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

mapa mp = "Mary", 70, "John", 60, "Susan", 50, "Pablo", 45, "Joseph", 75;
para (mapa:: iterator ite = mp.comenzar(); ite != MP.fin(); ite ++)
cout << ite->primero << " => " << ite->segundo << endl;
regresar 0;

La salida es:

John => 60
Joseph => 75
María => 70
Paul => 45
Susan => 50

La comparación es sensible a los casos. El programa comienza con la inclusión de la biblioteca IOSTream para el objeto Cout. A continuación, se incluye la biblioteca de mapas; y luego la biblioteca de cadenas también está incluida. La declaración que sigue asegura que cualquier nombre utilizado en el programa sea desde el espacio de nombres estándar a menos que se indique lo contrario.

En la función main (), el mapa se declara con inicialización. El siguiente segmento de código en la función Main () muestra el resultado ordenado (por clave).

Operador de comparación insensible de estuche personalizado

El menos que (<) operator of the string class of the C++ standard library is case-sensitive. If the programmer needs a case insensitive string literal less-than operator, he has to right his own operator function. An operator is actually a function that begins in a special way.

Desde el punto de vista del usuario, la operación menos que la operación es:

izquierda < right

Donde la izquierda y la derecha están los operandos. Esta operación produce verdadero si el operando izquierdo es menor que el operando derecho. Si sucede que el operando izquierdo es el mismo que el operando derecho o es mayor, produce falso. Este operador se utiliza para clasificar en orden ascendente.

Un operador de comparación menos insensible de estuche personalizado, para el literal de cadenas, es:

operador bool () (char const* izquierda, char const* derecho) const
para (; *izquierda != '\ 0' && *correcto != '\ 0'; ++ izquierda, ++ a la derecha)
if (tolower (*izquierda) != tolower (*correcto))

Return (tolower (*izquierda) < tolower(*right) );

más si ( *izquierda != *correcto)

if ( *(izquierda+1) == '\ 0' && *(derecha+1) == '\ 0')

Return (*izquierda < *right);



Return (tolower (*izquierda) < tolower(*right));

Aquí, el símbolo del operador no es <; it is (), which is coded to mean <. The arguments, left and right, are for the left and right operands, respectively. “char const*” means the content characters cannot be changed. “const” just after the parameter list, means the key value (string) referenced, in the map, cannot be changed, relative to the key/value pair. This does not mean that the order of each key/value pair element in the map cannot be changed.

A pesar del hecho de que el operador menos de lo menos que se ha definido como (), < is still used within the code.

El bucle de for-loop compara los literales de cadena izquierda y derecha, carácter por personaje, comenzando desde el personaje izquierdo más izquierdo. Verifica si los primeros caracteres de cada operando son los mismos cuando ambos están en minúsculas (bosconitentes insensibles). Si no son iguales, entonces verdadero se devuelve si el carácter izquierdo es menor que el carácter correcto; De lo contrario, se devuelve el falso; y la función del operador detiene la iteración porque la respuesta se ha obtenido. Si son iguales, la iteración continúa con el segundo par de caracteres correspondientes.

Antes de que la comparación continúe con el segundo par de caracteres correspondientes, el código verifica si los caracteres correspondientes eran los mismos pero de diferentes casos; y si los literales de cuerda tenían la misma longitud y han alcanzado sus fines. Si todo esto es verdadero, entonces se puede escribir para la clasificación de la orden descendente, pero eso no se abordará en este artículo.

Especialización de plantilla de comparación

En términos simples, la lista de parámetros de plantilla para el mapa es:

plantilla>

Observe el comparador predeterminado de menos. Para el mapa anterior, MP, y para la comparación insensible del caso, la especialización sería:

mapa

donde cicomp es el comparador, y es un tipo. Este tipo es el nombre de una estructura o el nombre de una clase. La estructura o clase generalmente tiene solo un miembro, que es la definición de función del operador anterior. En esta especialización, se ha utilizado "const char*" en lugar del tipo de cadena.

Con el tipo de estructura, los miembros no precedidos con el especificador, "Público:" son de manera predeterminada, pública. Con el tipo de clase, la función del operador anterior debe ser un miembro público. Entonces la definición de tipo de estructura sería:

struct cicomp
operador bool () (char const* izquierda, char const* derecho) const
para (; *izquierda != '\ 0' && *correcto != '\ 0'; ++ izquierda, ++ a la derecha)
if (tolower (*izquierda) != tolower (*correcto))

Return (tolower (*izquierda) < tolower(*right) );

más si ( *izquierda != *correcto)

if ( *(izquierda+1) == '\ 0' && *(derecha+1) == '\ 0')

Return (*izquierda < *right);



Return (tolower (*izquierda) < tolower(*right));

;

La principal diferencia entre las dos definiciones es el uso del especificador, "público". La definición de tipo de clase sería:

Clase Cicomp
público:
operador bool () (char const* izquierda, char const* derecho) const
para (; *izquierda != '\ 0' && *correcto != '\ 0'; ++ izquierda, ++ a la derecha)
if (tolower (*izquierda) != tolower (*correcto))

Return (tolower (*izquierda) < tolower(*right) );

más si ( *izquierda != *correcto)

if ( *(izquierda+1) == '\ 0' && *(derecha+1) == '\ 0')

Return (*izquierda < *right);



Return (tolower (*izquierda) < tolower(*right));

;

El programa para este comparador debe comenzar con:

#incluir <&iostreamgt;
#incluir <&mapgt;
#incluir <&cctypegt;
usando el espacio de nombres STD;

La biblioteca CCTYPE es para la función tolower ().

Función principal para un comparador personalizado

La siguiente función C ++ Main () es para el tipo de estructura o tipo de clase:

int main ()

mapa mp = "Mary", 70, "John", 60, "Susan", 50, "Pablo", 45, "Joseph", 75;
para (mapa:: iterator ite = mp.comenzar(); ite != MP.fin(); ite ++)
cout << ite->primero << " => " << ite->segundo << endl;
regresar 0;

La salida es,

John => 60
Joseph => 75
María => 70
Paul => 45
Susan => 50

Para el caso del comparador literal de cadena insensible. Tenga en cuenta que la especialización de plantilla para el iterador es la misma que la especialización de plantilla para el mapa.

Conclusión

El comparador predeterminado para la clasificación de mapas es menor. El comparador es un tipo cuyo nombre es el tercer argumento de la declaración del mapa, de la especialización de la plantilla de mapa. Este tipo puede ser una estructura o una clase, cuyo solo miembro posiblemente solo es una definición de operador personalizado. Este artículo ha mostrado el caso de un operador personalizado y menos que. Otros operadores de comparación se pueden definir de manera similar.