Mapa C ++ Classificação por chave

Um mapa consiste em pares de chave/valor. Cada par é um elemento. Todas as chaves em um mapa são únicas. Um mapa pode ser classificado por chaves. A classificação pode estar ascendente ou descendente. Ascender é o padrão. Classificar em um mapa nem sempre é direto. Precisa de um objeto de função de comparação. Se o objeto de comparação for ignorado, a classificação padrão ocorrer ocorrer.

Se as chaves forem constantes para caracteres, o mapa será classificado pelos principais indicadores, e não pelos literais de string-chave. Não é isso que ninguém quer. Considere os seguintes pares de frutas de chave/valores e suas cores externas:

"Plum" => "roxo"
"BlackBerry" => "escuro-preto"
"melancia" => "verde"
"Apricot", => "Orange"
"Papaya" => "laranja"
"banana" => "amarelo"

As frutas são as chaves, e as cores são os valores. Esta lista de elementos (pares de chave/valor) não é classificada. O programa a seguir cria um mapa desta lista como é e o exibe como é, não classificado por literais de string:

#incluir
#incluir
usando namespace std;
int main ()

mapa MP;
mp ["plum"] = "roxo";
MP ["BlackBerry"] = "Blue-preto escuro";
mp ["melancia"] = "verde";
MP ["Apricot"] = "Orange";
MP ["Papaya"] = "Orange";
MP ["banana"] = "amarelo";
para (mapa:: iterator it = MP.começar(); isto != MP.fim(); IT ++)
cout << it->primeiro << " => " << it->segundo << endl;
retornar 0;

A saída é:

Plum => roxo
BlackBerry => Blue-preto escuro
melancia => verde
damasco => laranja
Papaya => laranja
banana => amarelo

não classificado por literais de cordas, mas classificados por ponteiros. Para usar um mapa em um programa C ++, a biblioteca de mapas deve ser incluída com uma diretiva incluída.

Outra maneira de criar o mapa simples acima é a seguinte:

#incluir
#incluir
usando namespace std;
int main ()

mapa MP ("Plum", "Purple", "BlackBerry", "Dark Blue-Black", "Watermelon", "Green", "Apricot", "Orange", "Papaya" , "laranja", "banana", "amarelo");
para (mapa:: iterator it = MP.começar(); isto != MP.fim(); IT ++)
cout << it->primeiro << " => " << it->segundo << endl;
retornar 0;

A saída é:

Plum => roxo
BlackBerry => Blue-preto escuro
melancia => verde
damasco => laranja
Papaya => laranja
banana => amarelo

Unsorteado por literais de cordas, embora classificados por ponteiros. Se as chaves fossem números inteiros, a saída teria sido classificada por chaves. Na prática, as chaves de muitos mapas são literais de cordas. Este artigo explica como as chaves dos literais de cordas podem classificar um mapa.

Conteúdo do artigo

• Classificado durante a criação
• Produzindo um alcance descendo
• Comparando dois elementos por chave
• Classificação do mapa criado com a lista de inicializadores
• Conclusão

Classificar durante a criação

O modelo completo para a construção do mapa é:

modelo, Classe alocador = alocador>> mapa de classe;

As classes, comparam e alocador, têm valores padrão. Ou seja, eles têm especialização padrão, que não precisa ser digitada nas declarações do mapa (instanciações). O que é de interesse aqui é a classe de comparação. O nome da classe é comparado e a especialização padrão é "menos". "menos

Um mapa é normalmente criado classificado por chaves durante a criação. Se as chaves forem const char*, os ponteiros para as cordas literais citadas serão classificadas, não os textos literais. Para ter cordas como chaves classificadas durante a criação, as cordas devem ser literais de objetos de string instanciados da classe String. Isso significa que a biblioteca de string deve ser incluída, bem como a biblioteca de mapas.

Criando ascendente

No programa a seguir, o mapa é criado, classificada ascendente:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

mapa> MP;
mp ["plum"] = "roxo";
MP ["BlackBerry"] = "Blue-preto escuro";
mp ["melancia"] = "verde";
MP ["Apricot"] = "Orange";
MP ["Papaya"] = "Orange";
MP ["banana"] = "amarelo";
para (mapa:: iterator it = MP.começar(); isto != MP.fim(); IT ++)
cout << it->primeiro << " => " << it->segundo << endl;
retornar 0;

A saída é:

damasco => laranja
banana => amarelo
BlackBerry => Blue-preto escuro
Papaya => laranja
Plum => roxo
melancia => verde

Mesmo que menos fossem omitidos do modelo, a classificação ainda estaria subindo porque menos é o padrão.

Criando descendência

Para criar um mapa, de modo que seja classificado em ordem descendente por chaves, a especialização de comparação deve ser codificada. O programa a seguir ilustra o seguinte:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

mapa> MP;
mp ["plum"] = "roxo";
MP ["BlackBerry"] = "Blue-preto escuro";
mp ["melancia"] = "verde";
MP ["Apricot"] = "Orange";
MP ["Papaya"] = "Orange";
MP ["banana"] = "amarelo";
para (mapa:: iterator it = MP.começar(); isto != MP.fim(); IT ++)
cout << it->primeiro << " => " << it->segundo << endl;
retornar 0;

A saída é:

melancia => verde
Plum => roxo
Papaya => laranja
BlackBerry => Blue-preto escuro
banana => amarelo
damasco => laranja

Produzindo um alcance descendo

Uma variedade de um mapa pode ser produzida em ordem decrescente. Isso envolve a criação de um segundo mapa, que é um intervalo do primeiro mapa. O programa a seguir ilustra o seguinte:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

mapa MP;
mp ["plum"] = "roxo";
MP ["BlackBerry"] = "Blue-preto escuro";
mp ["melancia"] = "verde";
MP ["Apricot"] = "Orange";
MP ["Papaya"] = "Orange";
MP ["banana"] = "amarelo";
mapa:: iterator itb = MP.começar();
ITB ++;
mapa:: iterator ite = MP.fim();
eu te--;
mapa> MPR (ITB, ITE);
para (mapa:: iterator it = mpr.começar(); isto != mpr.fim(); IT ++)
cout << it->primeiro << " => " << it->segundo << endl;
retornar 0;

A saída é:

Plum => roxo
Papaya => laranja
BlackBerry => Blue-preto escuro
banana => amarelo

O primeiro objeto de mapa tem seis elementos que são:

damasco => laranja
banana => amarelo
BlackBerry => Blue-preto escuro
Papaya => laranja
Plum => roxo
melancia => verde

O intervalo considerado é:

banana => amarelo
BlackBerry => Blue-preto escuro
Papaya => laranja
Plum => roxo
melancia => verde

No código, "Itb ++" aponta para "banana", "amarelo" e "ite-" apontam para "melancia", "verde" para o intervalo. Ao lidar com um intervalo em C ++, o elemento final não está envolvido na manipulação. E assim a saída tem quatro elementos com “melancia”, “verde” omitido.

A especialização do parâmetro de modelo de comparação do segundo mapa é maior. Se fosse menor ou omitido, o intervalo teria resultado em ordem crescente.

Comparando dois elementos por chave

key_compare key_comp () const

Esta função de membro retorna uma cópia do objeto de comparação usado pelo contêiner do mapa para comparar as teclas. Um objeto de comparação é um objeto de função. Levaria duas chaves como argumentos e retornaria verdadeiro se a chave esquerda for menor que a direita. Com isso, o segmento de código deve ser:

key_compare kc = MP.key_comp ();
bool bl = kc ("melancia", "damasco");

key_compare não é reconhecido pelo compilador. Eliminando key_compare neste segmento de código, substituindo o KC na segunda declaração, resulta em:

bool bl = MP.key_comp () ("melancia", "damasco");

O programa a seguir ilustra o uso de key_comp ().

#incluir
#incluir
#incluir
usando namespace std;
int main ()

mapa MP;
mp ["plum"] = "roxo";
MP ["BlackBerry"] = "Blue-preto escuro";
mp ["melancia"] = "verde";
MP ["Apricot"] = "Orange";
MP ["Papaya"] = "Orange";
MP ["banana"] = "amarelo";
bool bl = MP.key_comp () ("melancia", "damasco");
cout << bl << endl;
retornar 0;

A saída é 0 para false.

O verdadeiro problema com o segmento de código acima é que o espaço para nome para key_compare não foi bem expresso. Se o segmento fosse,

mapa:: key_compare kc = MP.key_comp ();
bool bl = kc ("melancia", "damasco");

Teria funcionado (aceito pelo compilador).

value_compare value_comp () const

Esta função de membro é semelhante a key_comp (). Nota: Aqui, não é o valor do par de chaves/valor que é referido; É o elemento do par de chaves/valor. Portanto, os dois argumentos para o objeto de função value_compare são elementos de iterador. O programa a seguir usa value_comp (), ao comparar os primeiros e os últimos elementos, "Apricot", "Orange" e "Watermelon", "Green":

#incluir
#incluir
#incluir
usando namespace std;
int main ()

mapa> MP;
mp ["plum"] = "roxo";
MP ["BlackBerry"] = "Blue-preto escuro";
mp ["melancia"] = "verde";
MP ["Apricot"] = "Orange";
MP ["Papaya"] = "Orange";
MP ["banana"] = "amarelo";
mapa:: iterator itb = MP.começar();
mapa:: iterator ite = MP.fim();
eu te--;
mapa:: value_compare vc = MP.value_comp ();
bool bl = vc ( *itb, *ite);
cout << bl << endl;
retornar 0;

A saída é 1, para verdadeiro. Os iteradores ITB e ITE foram desreferenciados de ter seus elementos, com o operador indiretivo.

Classificação do mapa criado com a lista de inicializadores

No programa a seguir, onde a classificação está descendo, as chaves são objetos de string, instanciados da classe String:

#incluir
#incluir
#incluir
usando namespace std;
int main ()

mapa> MP ("Plum", "Purple", "BlackBerry", "Dark Blue-Black", "Watermelon", "Green", "Apricot", "Orange", "Papaya "," laranja ", " banana "," amarelo ");
para (mapa:: iterator it = MP.começar(); isto != MP.fim(); IT ++)
cout << it->primeiro << " => " << it->segundo << endl;
retornar 0;

A saída é:

melancia => verde
Plum => roxo
Papaya => laranja
BlackBerry => Blue-preto escuro
banana => amarelo
damasco => laranja

Conclusão

Um mapa é criado classificado por chaves, ascendendo. Ascender é a ordem padrão. Para descer, adicione a especialização do parâmetro de modelo, maior como o terceiro argumento, na lista de argumentos de modelo. Nota: Se as chaves forem strings, elas devem ser instanciadas da classe String, como ilustrado acima. Chaves de cordas como const-char* ou char-arr [], acabam com seus ponteiros classificados e não seus literais.