Comparatore di mappe C ++

Una mappa è una struttura di elementi di elementi. Ogni elemento è una coppia chiave/valore e le chiavi sono univoci. Una mappa può essere ordinata per chiavi dal più piccolo al più grande. In una sorta, una chiave si muove con il suo valore corrispondente. L'ordinamento in ordine crescente come questo utilizza il comparatore della mappa del modulo, meno di ().

Il seguente codice ordina una mappa per chiavi in ​​ordine crescente, durante la creazione della mappa:

carta geografica> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
per (mappa:: iterator ite = mp.inizio(); ite != mp.FINE(); ite ++)
cout << ite->Primo << " => " << ite->secondo << endl;

L'output è:

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

Il codice effettivo per il comparatore qui è "meno", nella specializzazione del modello di mappa. Il seguente codice ordina una mappa per chiavi in ​​ordine decrescente, durante la creazione della mappa:

carta geografica> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
per (mappa:: iterator ite = mp.inizio(); ite != mp.FINE(); ite ++)
cout << ite->Primo << " => " << ite->secondo << endl;

L'output è:

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

Il codice effettivo per il comparatore qui è "maggiore" nella specializzazione del modello di mappa.

Per i campioni di codice sopra, la libreria delle mappe è inclusa nel programma. Il modulo comparatore predefinito è inferiore. Quindi, avrebbe potuto essere omesso nel codice precedente,

carta geografica mp

Per la specializzazione del modello di mappa.

Se il programmatore non è soddisfatto del comparatore offerto da C ++, il programmatore può scrivere il proprio. Questo articolo spiega come il programmatore può applicare il proprio comparatore alla mappa. Confronto normale delle chiavi di stringa è sensibile al caso. Viene utilizzato l'esempio del confronto insensibile al caso.

Contenuto dell'articolo

• Confronto normale delle chiavi della stringa
• Operatore di confronto insensibile al caso personalizzato
• Specializzazione del modello di confronto
• Funzione principale per il comparatore personalizzato
• Conclusione

Confronto normale delle chiavi della stringa

Prendi in considerazione una classe di cinque studenti, per una mappa di nomi contro i marchi, in un test, come segue:

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

Una mappa C ++ per il comparatore predefinito, meno è nel programma:

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

carta geografica mp = "Mary", 70, "John", 60, "Susan", 50, "Paul", 45, "Joseph", 75;
per (mappa:: iterator ite = mp.inizio(); ite != mp.FINE(); ite ++)
cout << ite->Primo << " => " << ite->secondo << endl;
restituzione 0;

L'output è:

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

Il confronto è sensibile al caso. Il programma inizia con l'inclusione della libreria iostream per l'oggetto Cout. Successivamente, la libreria delle mappe è inclusa; e quindi è inclusa anche la libreria di stringhe. La dichiarazione che segue garantisce che qualsiasi nome utilizzato nel programma provenga dallo spazio dei nomi standard se non diversamente indicato.

Nella funzione principale (), la mappa viene dichiarata con l'inizializzazione. Il segmento di codice successivo nella funzione principale () visualizza il risultato ordinato (per chiave).

Operatore di confronto insensibile al caso personalizzato

Il meno che (<) 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.

Dal punto di vista dell'utente, l'operazione tutt'altro che:

Sinistra < right

dove sinistra e destra sono operandi. Questa operazione produce vera se l'operando sinistro è inferiore all'operando destro. Se succede che l'operando sinistro è uguale all'operando destro o è maggiore, produce falso. Questo operatore viene utilizzato per l'ordinamento in ordine crescente.

Un operatore di confronto insensibile al caso personalizzato, per il letterale della stringa, è:

bool operator () (char const* a sinistra, char const* destra) const
per (; *a sinistra != '\ 0' && *giusto != '\ 0'; ++ a sinistra, ++ a destra)
if (tolower (*a sinistra) != tolower (*a destra))

return (tolower (*a sinistra) < tolower(*right) );

altro se ( *lasciato != *a destra)

if ( *(sinistra+1) == '\ 0' && *(a destra+1) == '\ 0')

restituire (*a sinistra < *right);



return (tolower (*a sinistra) < tolower(*right));

Qui, il simbolo per l'operatore non lo è <; 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.

Nonostante il fatto che l'operatore non mirato non sia stato definito come (), < is still used within the code.

Il for-loop confronta i letterali di stringa sinistra e destra, personaggio per personaggio, a partire dal carattere più a sinistra. Verifica se i primi caratteri di ciascun operando sono gli stessi quando entrambi sono in minuscolo (insensibile al caso). Se non sono gli stessi, allora viene restituito se il carattere sinistro è inferiore al carattere destro; Altrimenti, False viene restituito; E la funzione dell'operatore interrompe l'iterazione perché la risposta è stata ottenuta. Se sono uguali, l'iterazione continua con la seconda coppia corrispondente di caratteri.

Prima che il confronto continui alla seconda coppia corrispondente di caratteri, il codice controlla se i caratteri corrispondenti erano uguali ma di casi diversi; e se i letterali delle corde avevano la stessa lunghezza e hanno raggiunto le loro estremità. Se tutti questi sono veri, allora il ", può essere scritto per l'ordinamento dell'ordine decrescente, ma questo non sarà affrontato in questo articolo.

Specializzazione del modello di confronto

In termini semplici, l'elenco dei parametri del modello per la mappa è:

modello>

Notare il comparatore predefinito di meno. Per la mappa sopra, MP e per il confronto insensibile del caso, la specializzazione sarebbe:

carta geografica

dove cicomp è il comparatore ed è un tipo. Questo tipo è il nome di una struttura o il nome di una classe. La struttura o la classe in genere ha un solo membro, che è la definizione della funzione dell'operatore sopra. In questa specializzazione, è stato utilizzato "const char*" al posto del tipo di stringa.

Con il tipo di strumento, i membri non preceduti con lo specificatore, "pubblico:" sono per impostazione predefinita, pubblico. Con il tipo di classe, la funzione dell'operatore sopra deve essere un membro pubblico. Quindi la definizione del tipo di strumento, sarebbe:

struct cicomp
bool operator () (char const* a sinistra, char const* destra) const
per (; *a sinistra != '\ 0' && *giusto != '\ 0'; ++ a sinistra, ++ a destra)
if (tolower (*a sinistra) != tolower (*a destra))

return (tolower (*a sinistra) < tolower(*right) );

altro se ( *lasciato != *a destra)

if ( *(sinistra+1) == '\ 0' && *(a destra+1) == '\ 0')

restituire (*a sinistra < *right);



return (tolower (*a sinistra) < tolower(*right));

;

La differenza principale tra le due definizioni è l'uso dello specificatore, "pubblico:". La definizione del tipo di classe sarebbe:

class cicomp
pubblico:
bool operator () (char const* a sinistra, char const* destra) const
per (; *a sinistra != '\ 0' && *giusto != '\ 0'; ++ a sinistra, ++ a destra)
if (tolower (*a sinistra) != tolower (*a destra))

return (tolower (*a sinistra) < tolower(*right) );

altro se ( *lasciato != *a destra)

if ( *(sinistra+1) == '\ 0' && *(a destra+1) == '\ 0')

restituire (*a sinistra < *right);



return (tolower (*a sinistra) < tolower(*right));

;

Il programma per questo comparatore dovrebbe iniziare con:

#includere <&iostreamgt;
#includere <&mapgt;
#includere <&cctypegt;
Utilizzo dello spazio dei nomi std;

La libreria CCType è per la funzione tolower ().

Funzione principale per il comparatore personalizzato

La seguente funzione C ++ Main () è per il tipo di strumento o il tipo di classe:

int main ()

carta geografica mp = "Mary", 70, "John", 60, "Susan", 50, "Paul", 45, "Joseph", 75;
per (mappa:: iterator ite = mp.inizio(); ite != mp.FINE(); ite ++)
cout << ite->Primo << " => " << ite->secondo << endl;
restituzione 0;

L'output è,

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

per il comparatore letterale della stringa insensibile al caso. Si noti che la specializzazione del modello per l'iteratore è la stessa della specializzazione del modello per la mappa.

Conclusione

Il comparatore predefinito per l'ordinamento della mappa è inferiore. Il comparatore è un tipo il cui nome è il terzo argomento della dichiarazione della mappa, della specializzazione del modello di mappa. Questo tipo può essere una struttura o una classe, il cui forse solo membro, è una definizione di operatore personalizzato. Questo articolo ha mostrato il caso per un operatore personalizzato e tutt'altro che. Altri operatori di confronto possono essere definiti.