Comparador de mapa C ++

Um mapa é uma estrutura de lista de elementos. Cada elemento é um par de chaves/valor e as chaves são únicas. Um mapa pode ser classificado por chaves do menor para o maior. Em uma espécie, uma chave se move com seu valor correspondente. Classificação em ordem ascendente como essa usa o comparador de mapa do formulário, menos do que ().

O código a seguir classifica um mapa por chaves em ordem crescente, durante a criação do mapa:

mapa> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
para (mapa:: iterator ite = MP.começar(); eu te != MP.fim(); ITE ++)
cout << ite->primeiro << " => " << ite->segundo << endl;

A saída é:

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

O código real para o comparador aqui é "menos", na especialização do modelo de mapa. O código a seguir classifica um mapa por chaves em ordem decrescente, durante a criação do mapa:

mapa> mp = 'p', 1, 'n', 2, 'q', 3, 'm', 4, 'o', 5;
para (mapa:: iterator ite = MP.começar(); eu te != MP.fim(); ITE ++)
cout << ite->primeiro << " => " << ite->segundo << endl;

A saída é:

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

O código real para o comparador aqui é "maior" na especialização do modelo de mapa.

Para as amostras de código acima, a biblioteca de mapas está incluída no programa. O formulário de comparador padrão é menor. Então, poderia ter sido omitido no código anterior para ter,

mapa MP

Para a especialização do modelo de mapa.

Se o programador não estiver satisfeito com o comparador oferecido por C ++, o programador pode escrever seu próprio. Este artigo explica como o programador pode aplicar seu próprio comparador ao mapa. A comparação normal das teclas de string é sensível ao maiúsculas. O exemplo de comparação insensível ao caso é usado.

Conteúdo do artigo

• Comparação normal de teclas de string
• Operador de comparação insensível ao caso personalizado
• Especialização do modelo de comparação
• Função principal para comparador personalizado
• Conclusão

Comparação normal de teclas de string

Considere uma turma de cinco alunos, para um mapa de nomes contra marcas, em um teste, como segue:

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

Um mapa C ++ para o comparador padrão, menos está no programa:

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

mapa mp = "Mary", 70, "John", 60, "Susan", 50, "Paul", 45, "Joseph", 75;
para (mapa:: iterator ite = MP.começar(); eu te != MP.fim(); ITE ++)
cout << ite->primeiro << " => " << ite->segundo << endl;
retornar 0;

A saída é:

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

A comparação é sensível ao minúsculo. O programa começa com a inclusão da biblioteca iostream para o objeto Cout. Em seguida, a biblioteca do mapa está incluída; e então a biblioteca de cordas também está incluída. A declaração a seguir garante que qualquer nome usado no programa seja do espaço de nome padrão, a menos que indicado de outra forma.

Na função principal (), o mapa é declarado com a inicialização. O próximo segmento de código na função Main () exibe o resultado classificado (por chave).

Operador de comparação insensível ao caso personalizado

O menos do 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.

Do ponto de vista do usuário, a operação menos do que é:

esquerda < right

onde esquerda e direita estão operando. Esta operação produz verdadeira se o operando esquerdo for menor que o operando direito. Se acontecer que o operando esquerdo é o mesmo que o operando certo ou é maior, ele produz falso. Este operador é usado para classificar em ordem crescente.

Um operador de comparação insensível a casos personalizados, para o literal de strings, é:

operador bool () (char const* esquerda, char const* direita) const
para (; *esquerda != '\ 0' && *certo != '\ 0'; ++ esquerda, ++ direita)
se (tolo (*esquerda) != tolo (*à direita))

Retorno (tolo (*esquerda) < tolower(*right) );

caso contrário, se ( *esquerda != *certo)

if ( *(esquerda+1) == '\ 0' && *(direita+1) == '\ 0')

retornar (*esquerda < *right);



Retorno (tolo (*esquerda) < tolower(*right));

Aqui, o símbolo do operador não é <; 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.

Apesar do fato de o operador menos do que o que foi definido como (), < is still used within the code.

O loop for compara os literais de cordas esquerda e direita, personagem por caracteres, começando a partir do caractere mais esquerdo. Ele verifica se os primeiros caracteres de cada operando são os mesmos quando ambos estão em minúsculas (insensíveis à caixa). Se eles não forem iguais, o verdadeiro será retornado se o personagem esquerdo for menor que o personagem certo; Caso contrário, False é devolvido; e a função do operador interrompe a iteração porque a resposta foi obtida. Se eles forem iguais, a iteração continua com o segundo par de caracteres correspondente.

Antes da comparação continuar com o segundo par de caracteres correspondente, o código verifica se os caracteres correspondentes eram os mesmos, mas de casos diferentes; e se os literais das cordas tivessem o mesmo comprimento e atingiram seus fins. Se tudo isso for verdadeiro, então o ", pode ser escrito para a classificação de ordem descendente, mas isso não será abordado neste artigo.

Especialização do modelo de comparação

Em termos simples, a lista de parâmetros do modelo para o mapa é:

modelo>

Observe o comparador padrão de menos. Para o mapa acima, MP e, para a comparação insensível ao caso, a especialização seria:

mapa

onde cicomp é o comparador e é um tipo. Este tipo é o nome de uma estrutura ou o nome de uma classe. A estrutura ou classe normalmente tem apenas um membro, que é a definição de função do operador acima. Nesta especialização, "const char*" foi usado em vez do tipo de string.

Com o tipo de estrutura, os membros não precedidos com o especificador, "público:" são por padrão, público. Com o tipo de classe, a função do operador acima deve ser um membro público. Portanto, a definição do tipo de estrutura seria:

estrutura cicomp
operador bool () (char const* esquerda, char const* direita) const
para (; *esquerda != '\ 0' && *certo != '\ 0'; ++ esquerda, ++ direita)
se (tolo (*esquerda) != tolo (*à direita))

Retorno (tolo (*esquerda) < tolower(*right) );

caso contrário, se ( *esquerda != *certo)

if ( *(esquerda+1) == '\ 0' && *(direita+1) == '\ 0')

retornar (*esquerda < *right);



Retorno (tolo (*esquerda) < tolower(*right));

;

A principal diferença entre as duas definições é o uso do especificador, “público:”. A definição do tipo de classe seria:

classe Cicomp
público:
operador bool () (char const* esquerda, char const* direita) const
para (; *esquerda != '\ 0' && *certo != '\ 0'; ++ esquerda, ++ direita)
se (tolo (*esquerda) != tolo (*à direita))

Retorno (tolo (*esquerda) < tolower(*right) );

caso contrário, se ( *esquerda != *certo)

if ( *(esquerda+1) == '\ 0' && *(direita+1) == '\ 0')

retornar (*esquerda < *right);



Retorno (tolo (*esquerda) < tolower(*right));

;

O programa para este comparador deve começar com:

#incluir <&iostreamgt;
#incluir <&mapgt;
#incluir <&cctypegt;
usando namespace std;

A biblioteca CCTYPE é para a função Tolower ().

Função principal para comparador personalizado

A função C ++ Main () a seguir é para o tipo de estrutura ou tipo de classe:

int main ()

mapa mp = "Mary", 70, "John", 60, "Susan", 50, "Paul", 45, "Joseph", 75;
para (mapa:: iterator ite = MP.começar(); eu te != MP.fim(); ITE ++)
cout << ite->primeiro << " => " << ite->segundo << endl;
retornar 0;

A saída é,

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

Para o caso, comparador literal de cordas insensíveis. Observe que a especialização do modelo para o iterador é a mesma que a especialização do modelo para o mapa.

Conclusão

O comparador padrão para classificação de mapas é menor. Comparador é um tipo cujo nome é o terceiro argumento da declaração do mapa, da especialização do modelo de mapa. Este tipo pode ser uma estrutura ou uma classe, cujo membro possivelmente apenas é uma definição de operador personalizado. Este artigo mostrou o caso para um operador personalizado e menos do que. Outros operadores de comparação podem ser definidos da mesma forma.