Comparateur de carte C ++

Une carte est une structure de liste d'éléments. Chaque élément est une paire de clés / valeur, et les clés sont uniques. Une carte peut être triée par des clés du plus petit à. En une sorte, une clé se déplace avec sa valeur correspondante. Le tri par ordre croissant comme celui-ci utilise le comparateur de carte de la forme, moins que ().

Le code suivant trie une carte par les clés dans l'ordre croissant, lors de la création de la carte:

carte> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
pour (carte:: iterator ite = mp.commencer(); ite != MP.fin(); ite ++)
couter << ite->d'abord << " => " << ite->deuxième << endl;

La sortie est:

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

Le code réel du comparateur ici est «moins», dans la spécialisation du modèle de carte. Le code suivant trie une carte par les clés dans l'ordre descendant, lors de la création de la carte:

carte> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
pour (carte:: iterator ite = mp.commencer(); ite != MP.fin(); ite ++)
couter << ite->d'abord << " => " << ite->deuxième << endl;

La sortie est:

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

Le code réel du comparateur ici est «plus grand» dans la spécialisation du modèle de carte.

Pour les échantillons de code ci-dessus, la bibliothèque de cartes est incluse dans le programme. Le formulaire de comparateur par défaut est moindre. Donc, il aurait pu être omis dans le code précédent,

carte député

Pour la spécialisation du modèle de carte.

Si le programmeur n'est pas satisfait du comparateur offert par C ++, le programmeur peut écrire le sien. Cet article explique comment le programmeur peut appliquer son propre comparateur à la carte. La comparaison normale des touches de chaîne est sensible à la casse. L'exemple de comparaison insensible à la cas est utilisé.

Contenu de l'article

• Comparaison normale des touches de chaîne
• Opérateur de comparaison insensible au boîtier personnalisé
• Spécialisation du modèle de comparaison
• Fonction principale pour le comparateur personnalisé
• Conclusion

Comparaison normale des touches de chaîne

Considérez une classe de cinq étudiants, pour une carte des prénoms contre les marques, dans un test, comme suit:

Mary => 70
John => 60
Susan => 50
Paul => 45
Joseph => 75

Une carte C ++ pour le comparateur par défaut, moins est dans le programme:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte mp = "Mary", 70, "John", 60, "Susan", 50, "Paul", 45, "Joseph", 75;
pour (carte:: iterator ite = mp.commencer(); ite != MP.fin(); ite ++)
couter << ite->d'abord << " => " << ite->deuxième << endl;
retour 0;

La sortie est:

John => 60
Joseph => 75
Mary => 70
Paul => 45
Susan => 50

La comparaison est sensible à la casse. Le programme commence par l'inclusion de la bibliothèque iOStream pour l'objet cout. Ensuite, la bibliothèque de cartes est incluse; Et puis la bibliothèque de chaînes est également incluse. L'énoncé qui suit garantit que tout nom utilisé dans le programme provient de l'espace de noms standard, sauf indication contraire.

Dans la fonction principale (), la carte est déclarée avec initialisation. Le segment de code suivant dans la fonction principale () affiche le résultat trié (par clé).

Opérateur de comparaison insensible au boîtier personnalisé

Le moins 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.

Du point de vue de l'utilisateur, l'opération moins que celle est:

gauche < right

où la gauche et la droite sont des opérandes. Cette opération crée True si l'opérande gauche est inférieur à l'opérande droit. S'il arrive que l'opérande gauche est le même que l'opérande droit ou est plus élevé, il donne faux. Cet opérateur est utilisé pour le tri par ordre croissant.

Un opérateur de comparaison moins insensible à un cas personnalisé, pour la chaîne littérale, est:

Bool Operator () (char const * gauche, char const * droite) const
pour (; * gauche != '\ 0' && * à droite != '\ 0'; ++ gauche, ++ droite)
if (Tolower (* à gauche) != Tolower (* à droite))

retour (Tolower (* à gauche) < tolower(*right) );

sinon si (* gauche != * à droite)

if (* (gauche + 1) == '\ 0' && * (droite + 1) == '\ 0')

retour (* gauche < *right);



retour (Tolower (* à gauche) < tolower(*right));

Ici, le symbole de l'opérateur n'est pas <; 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.

Malgré le fait que l'opérateur moins ciblé ait été défini comme (), < is still used within the code.

La boucle à forte compare les littéraux de cordes gauche et droite, caractéristique par caractère, à partir du plus à gauche. Il vérifie si les premiers caractères de chaque opérande sont les mêmes lorsque les deux sont en minuscules (cas insensible). S'ils ne sont pas les mêmes, alors vrai est renvoyé si le caractère gauche est inférieur au caractère droit; Sinon, false est retourné; Et la fonction de l'opérateur arrête l'itération car la réponse a été obtenue. S'ils sont les mêmes, alors l'itération se poursuit avec la deuxième paire de caractères correspondante.

Avant que la comparaison ne continue à la deuxième paire de caractères correspondante, le code vérifie si les caractères correspondants étaient les mêmes mais des cas différents; Et si les littéraux de cordes étaient de la même longueur et ont atteint leurs extrémités. Si tout cela est vrai, alors le ”, peut être écrit pour le tri des ordonnances décroissant, mais cela ne sera pas abordé dans cet article.

Spécialisation du modèle de comparaison

En termes simples, la liste des paramètres du modèle pour la carte est:

modèle>

Remarquez le comparateur par défaut de moins. Pour la carte ci-dessus, MP et pour la comparaison insensible au cas, la spécialisation serait:

carte

où Cicomp est le comparateur, et c'est un type. Ce type est le nom d'une structure ou le nom d'une classe. La structure ou la classe n'a généralement qu'un seul membre, qui est la définition de la fonction de l'opérateur ci-dessus. Dans cette spécialisation, «const char *» a été utilisé à la place du type de chaîne.

Avec le type de structure, les membres non précédés du spécificateur, «public», sont par défaut, public. Avec le type de classe, la fonction d'opérateur ci-dessus doit être un membre public. Ainsi, la définition du type de structure serait:

struct cicomp
Bool Operator () (char const * gauche, char const * droite) const
pour (; * gauche != '\ 0' && * à droite != '\ 0'; ++ gauche, ++ droite)
if (Tolower (* à gauche) != Tolower (* à droite))

retour (Tolower (* à gauche) < tolower(*right) );

sinon si (* gauche != * à droite)

if (* (gauche + 1) == '\ 0' && * (droite + 1) == '\ 0')

retour (* gauche < *right);



retour (Tolower (* à gauche) < tolower(*right));

;

La principale différence entre les deux définitions est l'utilisation du spécificateur, «public:». La définition du type de classe serait:

classe Cicomp
public:
Bool Operator () (char const * gauche, char const * droite) const
pour (; * gauche != '\ 0' && * à droite != '\ 0'; ++ gauche, ++ droite)
if (Tolower (* à gauche) != Tolower (* à droite))

retour (Tolower (* à gauche) < tolower(*right) );

sinon si (* gauche != * à droite)

if (* (gauche + 1) == '\ 0' && * (droite + 1) == '\ 0')

retour (* gauche < *right);



retour (Tolower (* à gauche) < tolower(*right));

;

Le programme de ce comparateur doit commencer:

#inclure <&iostreamgt;
#inclure <&mapgt;
#inclure <&cctypegt;
Utilisation de Namespace Std;

La bibliothèque CCTYPE est pour la fonction Tolower ().

Fonction principale pour le comparateur personnalisé

La fonction C ++ Main () suivante est pour le type de structure ou le type de classe:

int main()

carte mp = "Mary", 70, "John", 60, "Susan", 50, "Paul", 45, "Joseph", 75;
pour (carte:: iterator ite = mp.commencer(); ite != MP.fin(); ite ++)
couter << ite->d'abord << " => " << ite->deuxième << endl;
retour 0;

La sortie est,

John => 60
Joseph => 75
Mary => 70
Paul => 45
Susan => 50

Pour le cas, un comparateur littéral de cordes insensible. Notez que la spécialisation du modèle pour l'itérateur est la même que la spécialisation du modèle pour la carte.

Conclusion

Le comparateur par défaut pour le tri des cartes est moindre. Le comparateur est un type dont le nom est le troisième argument de la déclaration de carte, de la spécialisation du modèle de carte. Ce type peut être une structure ou une classe, dont le seul membre peut être une définition de l'opérateur personnalisé. Cet article a montré le cas d'un opérateur personnalisé et moins que. D'autres opérateurs de comparaison peuvent également être définis.