Classe hash_map
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Armazena e recupera dados rapidamente de uma coleção em que cada elemento é um par que tem uma chave de classificação cujo valor é exclusivo, bem como um valor de dados associado.
Sintaxe
template <class Key,
class Type,
class Traits=hash_compare<Key, less<Key>>,
class Allocator=allocator<pair <const Key, Type>>>
class hash_map
Parâmetros
Key
O tipo de dados da chave a ser armazenado no hash_map
.
Type
O tipo de dados do elemento a ser armazenado no hash_map
.
Traits
O tipo que inclui dois objetos de função: um da classe compare, para comparar dois valores de elemento como chaves de classificação para determinar sua ordem relativa e uma função de hash, que é um predicado unário que mapeia valores chave dos elementos para inteiros sem sinal do tipo size_t
. Esse argumento é opcional e hash_compare<Key, less<Key>>
é o valor padrão.
Allocator
O tipo que representa o objeto de alocador armazenado que encapsula detalhes sobre a alocação e a desalocação do hash_map
da memória. Esse argumento é opcional e o valor padrão é allocator<pair <const Key, Type>>
.
Comentários
O hash_map
é:
Um contêiner associativo, que é um contêiner de tamanho variável que oferece suporte à recuperação eficiente dos valores de elemento com base em um valor de chave associado.
Reversível, pois fornece um iterador bidirecional para acessar seus elementos.
Com hash, pois seus elementos são agrupados em buckets com base no valor de uma função de hash aplicada aos valores chave dos elementos.
Exclusivo no sentido de que cada um de seus elementos deve ter uma chave exclusiva.
Um contêiner de par associativo, pois seus valores de dados de elemento são distintos de seus valores de chave.
Um modelo de classe, pois a funcionalidade fornecida por ela é genérica e, portanto, independente do tipo de dados específico contido como elementos ou chaves. Os tipos de dados a serem usados para elementos e chaves são especificados como parâmetros no modelo de classe juntamente com o alocador e a função de comparação.
A principal vantagem do uso de hash em vez da classificação é a maior eficiência: um hash bem-sucedido executa inserções, exclusões e localizações em tempos médios constantes, em comparação com um tempo proporcional ao logaritmo do número de elementos no contêiner para técnicas de classificação. O valor de um elemento em um hash_map
, mas não seu valor de chave associado, pode ser alterado diretamente. Em vez disso, os valores de chave associados aos elementos antigos devem ser excluídos e os novos valores de chave associados aos novos elementos inseridos.
A escolha do tipo de contêiner deve se basear, de modo geral, no tipo de pesquisa e inserção exigido pelo aplicativo. Contêineres associativos com hash são otimizados para as operações de pesquisa, inserção e remoção. As funções membro que dão suporte explicitamente a essas operações são eficientes quando usadas com uma função de hash bem elaborada, executando-as em um tempo que é, em média, constante e não dependente do número de elementos no contêiner. Uma função de hash bem elaborada produz uma distribuição uniforme de valores em hash e minimiza o número de colisões, em que uma colisão deve ocorrer quando valores de chave distintos são mapeados para o mesmo valor em hash. No pior caso, com a pior função de hash possível, o número de operações será proporcional ao número de elementos na sequência (tempo linear).
O hash_map
deve ser o contêiner associativo escolhido quando as condições que associam os valores às respectivas chaves forem atendidas pelo aplicativo. Um modelo para esse tipo de estrutura é uma lista ordenada de palavras-chave que ocorrem uma única vez e com valores de cadeia de caracteres associados que forneçam definições. Se as palavras tiverem mais de uma definição correta, as chave não seriam exclusivas, de modo que um hash_multimap
seria o contêiner ideal. Se, por outro lado, apenas as listas de palavras foram sendo armazenadas, um hash_set
seria o contêiner correto. Se não foram permitidas as várias ocorrências das palavras, um hash_multiset
seria a estrutura de contêiner apropriada.
O hash_map
ordena a sequência que controla chamando um objeto Traits
de hash armazenado da classe value_compare
. Esse objeto armazenado pode ser acessado chamando a função membro key_comp
. Um objeto de função precisa se comportar da mesma forma que um objeto da classe hash_compare<Key, less<Key>>
. Especificamente, para todos os valores de Key
do tipo Key
, a chamada Traits
( Key
) produz uma distribuição de valores do tipo size_t
. Para obter mais informações, consulte hash_compare
.
De modo geral, os elementos precisam ser simplesmente menores que os comparáveis para estabelecer essa ordem: desse modo, considerando dois elementos, pode ser determinado que, ou eles são equivalentes (no sentido de que nenhum deles é menor que o outro), ou que um é menor que o outro. Isso resulta em uma ordenação entre os elementos não equivalentes. Fazendo uma observação mais técnica, a função de comparação é um predicado binário que induz a uma ordenação fraca restrita no sentido matemático padrão. Um predicado binário f(x,y) é um objeto de função que tem dois objetos de argumento x
e y
e um valor retornado de true
ou false
. Uma ordenação imposta a um hash_map
será uma ordenação fraca restrita se o predicado binário for irreflexivo, antissimétrico e transitivo e se a equivalência for transitiva, em que dois objetos x
e y
são definidos para serem equivalentes quando f( x, y) e f( y, x) forem false
. Se a condição mais forte de igualdade entre as chaves substituir essa equivalência, a ordenação será total (no sentido de que todos os elementos serão ordenados um em relação ao outro) e as chaves correspondentes não poderão ser diferenciadas uma da outra.
A ordem real dos elementos na sequência controlada depende da função de hash, da função de ordenação e do tamanho atual da tabela de hash armazenada no objeto de contêiner. Você não pode determinar o tamanho atual da tabela de hash, portanto, não pode, em geral, prever a ordem dos elementos na sequência controlada. A inserção de elementos não invalida iteradores e a remoção de elementos invalida apenas os iteradores que apontavam especificamente os elementos removidos.
O iterador fornecido pela classe hash_map
é um iterador bidirecional, mas as funções membro de classe insert
e hash_map
têm versões que usam como parâmetros de modelo um iterador de entrada mais fraco, cujos requisitos de funcionalidade são mais minimalistas do que aqueles assegurados pela classe de iteradores bidirecionais. Os conceitos de iterador diferente formam uma família relacionada por refinamentos em sua funcionalidade. Cada conceito de iterador tem seu próprio conjunto de requisitos e os algoritmos que funcionam com eles devem limitar suas suposições para os requisitos fornecidos por esse tipo de iterador. Pode ser pressuposto que um iterador de entrada possa ser desreferenciado para fazer referência a algum objeto e que possa ser incrementado para o próximo iterador na sequência. Esse é um conjunto mínimo de funcionalidade, mas é suficiente para poder expressar de forma significativa um intervalo de iteradores [First, Last)
no contexto de funções membro da classe.
Construtores
Construtor | Descrição |
---|---|
hash_map |
Constrói um hash_map que está vazio ou que é uma cópia de todo ou parte de algum outro hash_map . |
Typedefs
Nome do tipo | Descrição |
---|---|
allocator_type |
Um tipo que representa a classe allocator para o objeto hash_map . |
const_iterator |
Um tipo que fornece um iterador bidirecional que pode ler um elemento const no hash_map . |
const_pointer |
Um tipo que fornece um ponteiro para um elemento const em um hash_map . |
const_reference |
Um tipo que fornece uma referência para um elemento const armazenado em um hash_map para leitura e execução de operações const . |
const_reverse_iterator |
Um tipo que fornece um iterador bidirecional que pode ler qualquer elemento const no hash_map . |
difference_type |
Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de um hash_map em um intervalo entre os elementos apontado pelos iteradores. |
iterator |
Um tipo que fornece um iterador bidirecional que pode ler ou modificar qualquer elemento em um hash_map . |
key_compare |
Um tipo que fornece um objeto de função que pode comparar duas chaves de classificação para determinar a ordem relativa de dois elementos no hash_map . |
key_type |
Um tipo que descreve o objeto de chave de classificação que constitui cada elemento do hash_map . |
mapped_type |
Um tipo que representa o tipo de dados armazenado em um hash_map . |
pointer |
Um tipo que fornece um ponteiro para um elemento em um hash_map . |
reference |
Um tipo que fornece uma referência a um elemento armazenado em um hash_map . |
reverse_iterator |
Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um hash_map invertido. |
size_type |
Um tipo de inteiro sem sinal que pode representar o número de elementos em um hash_map . |
value_type |
Um tipo que fornece um objeto de função que pode comparar dois elementos como chaves de classificação para determinar sua ordem relativa no hash_map . |
Funções de membro
Função de membro | Descrição |
---|---|
at |
Localiza um elemento em um hash_map com um valor de chave especificado. |
begin |
Retorna um iterador que trata o primeiro elemento no hash_map . |
cbegin |
Retorna um iterador const que trata o primeiro elemento no hash_map . |
cend |
Retorna um iterador const que trata o local após o último elemento em um hash_map . |
clear |
Apaga todos os elementos de um hash_map . |
count |
Retorna o número de elementos em um hash_map cuja chave corresponde a uma chave especificada pelo parâmetro. |
crbegin |
Retorna um iterador const que trata o primeiro elemento em um hash_map invertido. |
crend |
Retorna um iterador const que trata o local após o último elemento em um hash_map invertido. |
emplace |
Insere um elemento construído adequadamente em um hash_map . |
emplace_hint |
Insere um elemento construído adequadamente em um hash_map , com uma dica de posicionamento. |
empty |
Testa se hash_map está vazio. |
end |
Retorna um iterador que trata o local após o último elemento em um hash_map . |
equal_range |
Retorna um par de iteradores, respectivamente, para o primeiro elemento em um hash_map com uma chave que é maior do que uma chave especificada e para o primeiro elemento no hash_map com uma chave igual ou maior que a chave. |
erase |
Remove um elemento ou um intervalo de elementos em um hash_map das posições especificadas |
find |
Retorna um iterador que trata do local de um elemento em um hash_map que tem uma chave equivalente a uma chave especificada. |
get_allocator |
Retorna uma cópia do objeto allocator usada para construir o hash_map . |
insert |
Insere um elemento ou um intervalo de elementos em um hash_map . |
key_comp |
Retorna um iterador para o primeiro elemento em um hash_map com um valor de chave que é igual ou maior que uma chave especificada. |
lower_bound |
Retorna um iterador para o primeiro elemento em um hash_map com um valor de chave que é igual ou maior que uma chave especificada. |
max_size |
Retorna o comprimento máximo do hash_map . |
rbegin |
Retorna um iterador que trata o primeiro elemento em um hash_map invertido. |
rend |
Retorna um iterador que trata o local após o último elemento em um hash_map invertido. |
size |
Retorna o número de elementos no hash_map . |
swap |
Troca os elementos de dois hash_map s. |
upper_bound |
Retorna um iterador para o primeiro elemento em um hash_map que tem um valor de chave que é maior que uma chave especificada. |
value_comp |
Recupera uma cópia do objeto de comparação usado para ordenar valores de elemento em um hash_map . |
Operadores
Operador | Descrição |
---|---|
operator[] |
Insere um elemento em um hash_map com um valor de chave especificado. |
hash_map::operator= |
Substitui os elementos de um hash_map por uma cópia de outro hash_map . |
Requisitos
Cabeçalho: <hash_map>
Namespace: stdext
hash_map::allocator_type
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que representa a classe allocator do objeto hash_map.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;
Exemplo
Veja o exemplo de get_allocator
para obter um exemplo que usa allocator_type
.
hash_map::at
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Localiza um elemento em um hash_map
com um valor de chave especificado.
Type& at(const Key& key);
const Type& at(const Key& key) const;
Parâmetros
key
O valor de chave do elemento que deve ser encontrado.
Valor de retorno
Uma referência ao valor de dados do elemento encontrado.
Comentários
Se o valor da chave do argumento não for encontrado, a função lançará um objeto da classe out_of_range
Classe.
Exemplo
// hash_map_at.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
typedef pair <const int, int> cInt2Int;
hash_map <int, int> hm1;
// Insert data values
hm1.insert ( cInt2Int ( 1, 10 ) );
hm1.insert ( cInt2Int ( 2, 20 ) );
hm1.insert ( cInt2Int ( 3, 30 ) );
cout << "The values of the mapped elements are:";
for ( int i = 1 ; i <= hm1.size() ; i++ )
cout << " " << hm1.at(i);
cout << "." << endl;
}
hash_map::begin
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador que trata o primeiro elemento no hash_map
.
const_iterator begin() const;
iterator begin();
Valor de retorno
Um iterador bidirecional que trata o primeiro elemento no hash_map
ou o local após um hash_map
vazio.
Exemplo
// hash_map_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: iterator hm1_Iter;
hash_map <int, int> :: const_iterator hm1_cIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 0, 0 ) );
hm1.insert ( Int_Pair ( 1, 1 ) );
hm1.insert ( Int_Pair ( 2, 4 ) );
hm1_cIter = hm1.begin ( );
cout << "The first element of hm1 is "
<< hm1_cIter -> first << "." << endl;
hm1_Iter = hm1.begin ( );
hm1.erase ( hm1_Iter );
// The following 2 lines would err because the iterator is const
// hm1_cIter = hm1.begin ( );
// hm1.erase ( hm1_cIter );
hm1_cIter = hm1.begin( );
cout << "The first element of hm1 is now "
<< hm1_cIter -> first << "." << endl;
}
The first element of hm1 is 0.
The first element of hm1 is now 1.
hash_map::cbegin
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador const que trata o primeiro elemento no hash_map
.
const_iterator cbegin() const;
Valor de retorno
Um iterador bidirecional const que trata o primeiro elemento no hash_map
ou o local após um hash_map
vazio.
Exemplo
// hash_map_cbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: const_iterator hm1_cIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 2, 4 ) );
hm1_cIter = hm1.cbegin ( );
cout << "The first element of hm1 is "
<< hm1_cIter -> first << "." << endl;
}
The first element of hm1 is 2.
hash_map::cend
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador const que trata o local após o último elemento em um hash_map
.
const_iterator cend() const;
Valor de retorno
Retorna um iterador bidirecional const que trata o local após o último elemento em um hash_map
. Se o hash_map
estiver vazio, então hash_map::cend == hash_map::begin
.
Comentários
cend
é usado para testar se um iterador atingiu o fim de seu hash_map
.
O valor retornado por cend
não deve ser desreferenciado.
Exemplo
// hash_map_cend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: const_iterator hm1_cIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_cIter = hm1.cend( );
hm1_cIter--;
cout << "The value of last element of hm1 is "
<< hm1_cIter -> second << "." << endl;
}
The value of last element of hm1 is 30.
hash_map::clear
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Apaga todos os elementos de um hash_map
.
void clear();
Comentários
Exemplo
O exemplo a seguir demonstra o uso da função de membro hash_map::clear
.
// hash_map_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map<int, int> hm1;
hash_map<int, int>::size_type i;
typedef pair<int, int> Int_Pair;
hm1.insert(Int_Pair(1, 1));
hm1.insert(Int_Pair(2, 4));
i = hm1.size();
cout << "The size of the hash_map is initially "
<< i << "." << endl;
hm1.clear();
i = hm1.size();
cout << "The size of the hash_map after clearing is "
<< i << "." << endl;
}
The size of the hash_map is initially 2.
The size of the hash_map after clearing is 0.
hash_map::const_iterator
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece um iterador bidirecional que pode ler um elemento const
no hash_map
.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;
Comentários
Um tipo const_iterator
não pode ser usado para modificar o valor de um elemento.
O const_iterator
definido por hash_map
aponta para elementos que são objetos de value_type
, que são do tipo pair< const Key, Type >
, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.
Para desreferenciar um const_iterator
cIter
apontamento para um elemento em um hash_map
, use o ->
operador.
Para acessar o valor de chave do elemento, use cIter->first
, que é equivalente a (*cIter).first
. Para acessar o valor dos dados mapeados do elemento, use cIter->second
, que é equivalente a (*cIter).second
.
Exemplo
Veja o exemplo de begin
para obter um exemplo que usa const_iterator
.
hash_map::const_pointer
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece um ponteiro para um elemento const
em um hash_map
.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;
Comentários
Um tipo const_pointer
não pode ser usado para modificar o valor de um elemento.
Na maioria dos casos, um iterator
deve ser usado para acessar os elementos em um objeto hash_map
.
hash_map::const_reference
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece uma referência para um elemento const
armazenado em um hash_map
para leitura e execução de operações const
.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;
Comentários
Exemplo
// hash_map_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map<int, int> hm1;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
// Declare and initialize a const_reference &Ref1
// to the key of the first element
const int &Ref1 = ( hm1.begin( ) -> first );
// The following line would cause an error because the
// non-const_reference cannot be used to access the key
// int &Ref1 = ( hm1.begin( ) -> first );
cout << "The key of the first element in the hash_map is "
<< Ref1 << "." << endl;
// Declare and initialize a reference &Ref2
// to the data value of the first element
int &Ref2 = ( hm1.begin( ) -> second );
cout << "The data value of the first element in the hash_map is "
<< Ref2 << "." << endl;
}
The key of the first element in the hash_map is 1.
The data value of the first element in the hash_map is 10.
hash_map::const_reverse_iterator
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece um iterador bidirecional que pode ler qualquer elemento const
no hash_map
.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse)iterator const_reverse_iterator;
Comentários
Um tipo const_reverse_iterator
não pode modificar o valor de um elemento e é usado para iterar o hash_map
invertido.
O const_reverse_iterator
definido por hash_map
aponta para elementos que são objetos de value_type
, que são do tipo pair< const Key, Type >
, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.
Para desreferenciar um const_reverse_iterator
crIter
apontamento para um elemento em um hash_map
, use o ->
operador.
Para acessar o valor de chave do elemento, use crIter->first
, que é equivalente a (*crIter).first
. Para acessar o valor dos dados mapeados do elemento, use crIter->second
, que é equivalente a (*crIter).first
.
Exemplo
Veja o exemplo de rend
que demonstra como declarar e usar o const_reverse_iterator
.
hash_map::count
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna o número de elementos em um hash_map
cuja chave corresponde a uma chave especificada pelo parâmetro.
size_type count(const Key& key) const;
Parâmetros
key
O valor de chave dos elementos a serem correspondidos a partir de hash_map
.
Valor de retorno
1, se o hash_map
tiver um elemento cuja chave de classificação corresponde à chave de parâmetro; 0, se o hash_map
não tiver um elemento com uma chave correspondente.
Comentários
A função membro retorna o número de elementos x
no intervalo
lower_bound(key)
, upper_bound(key)
que será 0 ou 1, no caso de hash_map
, que é um contêiner associativo exclusivo.
Exemplo
O exemplo a seguir demonstra o uso da função de membro hash_map::count
.
// hash_map_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main()
{
using namespace std;
using namespace stdext;
hash_map<int, int> hm1;
hash_map<int, int>::size_type i;
typedef pair<int, int> Int_Pair;
hm1.insert(Int_Pair (1, 1));
hm1.insert(Int_Pair (2, 1));
hm1.insert(Int_Pair (1, 4));
hm1.insert(Int_Pair (2, 1));
// Keys must be unique in hash_map, so duplicates are ignored
i = hm1.count(1);
cout << "The number of elements in hm1 with a sort key of 1 is: "
<< i << "." << endl;
i = hm1.count(2);
cout << "The number of elements in hm1 with a sort key of 2 is: "
<< i << "." << endl;
i = hm1.count(3);
cout << "The number of elements in hm1 with a sort key of 3 is: "
<< i << "." << endl;
}
The number of elements in hm1 with a sort key of 1 is: 1.
The number of elements in hm1 with a sort key of 2 is: 1.
The number of elements in hm1 with a sort key of 3 is: 0.
hash_map::crbegin
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador const
que trata o primeiro elemento em um hash_map
invertido.
const_reverse_iterator crbegin() const;
Valor de retorno
Um iterador bidirecional invertido const
que trata o primeiro elemento em um hash_map
invertido ou que endereça o que foi o último elemento no hash_map
não invertido.
Comentários
crbegin
é usado com um hash_map
invertido, assim como begin
é usado com um hash_map
.
Com o valor retornado crbegin
, o objeto hash_map
não pode ser modificado.
crbegin
pode ser usado para iterar em um hash_map
no sentido inverso.
Exemplo
// hash_map_crbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: const_reverse_iterator hm1_crIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_crIter = hm1.crbegin( );
cout << "The first element of the reversed hash_map hm1 is "
<< hm1_crIter -> first << "." << endl;
}
The first element of the reversed hash_map hm1 is 3.
hash_map::crend
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador const
que trata o local após o último elemento em um hash_map
invertido.
const_reverse_iterator crend() const;
Valor de retorno
Um iterador bidirecional inverso const
que trata a localização que vem após o último elemento em um hash_map
invertido (o local que precedeu o primeiro elemento no hash_map
não invertido).
Comentários
crend
é usado com um hash_map
invertido, assim como hash_map::end
é usado com um hash_map
.
Com o valor retornado crend
, o objeto hash_map
não pode ser modificado.
crend
pode ser usado para testar se um iterador inverso alcançou o final de sua hash_map
.
O valor retornado por crend
não deve ser desreferenciado.
Exemplo
// hash_map_crend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: const_reverse_iterator hm1_crIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_crIter = hm1.crend( );
hm1_crIter--;
cout << "The last element of the reversed hash_map hm1 is "
<< hm1_crIter -> first << "." << endl;
}
The last element of the reversed hash_map hm1 is 3.
hash_map::difference_type
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo de inteiro com sinal que pode ser usado para representar o número de elementos de um hash_map
em um intervalo entre os elementos apontado pelos iteradores.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::difference_type difference_type;
Exemplo
// hash_map_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 3, 20 ) );
// The following won't insert, because map keys are unique
hm1.insert ( Int_Pair ( 2, 30 ) );
hash_map <int, int>::iterator hm1_Iter, hm1_bIter, hm1_eIter;
hm1_bIter = hm1.begin( );
hm1_eIter = hm1.end( );
// Count the number of elements in a hash_map
hash_map <int, int>::difference_type df_count = 0;
hm1_Iter = hm1.begin( );
while ( hm1_Iter != hm1_eIter)
{
df_count++;
hm1_Iter++;
}
cout << "The number of elements in the hash_map hm1 is: "
<< df_count << "." << endl;
cout << "The keys of the mapped elements are:";
for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
hm1_Iter++)
cout << " " << hm1_Iter-> first;
cout << "." << endl;
cout << "The values of the mapped elements are:";
for ( hm1_Iter= hm1.begin( ) ; hm1_Iter!= hm1.end( ) ;
hm1_Iter++)
cout << " " << hm1_Iter-> second;
cout << "." << endl;
}
The number of elements in the hash_map hm1 is: 3.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 20.
hash_map::emplace
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Insere um elemento construído adequadamente em um hash_map
.
template <class ValTy>
pair <iterator, bool>
emplace(
ValTy&& val);
Parâmetros
val
O valor usado para construir um elemento a ser inserido no hash_map
, a menos que o hash_map
já contenha o elemento (ou, de modo geral, um elemento cuja chave seja ordenada de maneira equivalente).
Valor de retorno
A função membro emplace
retorna um par cujo componente bool
retorna true
se uma inserção tiver sido feita e false
se o hash_map
já contivesse um elemento cuja chave tinha um valor equivalente na ordenação e cujo componente iterator
retorna o endereço em que um novo elemento foi inserido ou onde o elemento já estava localizado.
Para acessar o componente iterator
de um par pr
retornado por essa função membro, use pr.first
e, para desreferenciar, use *(pr.first)
. Para acessar o componente bool
de um par pr
retornado por essa função membro, use pr.second
e, para desreferenciar, use *(pr.second)
.
Comentários
O hash_map::value_type
de um elemento é um par, de forma que o valor de um elemento será um par ordenado com o primeiro componente igual ao valor de chave e o segundo componente igual ao valor dos dados do elemento.
Exemplo
// hash_map_emplace.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>
int main()
{
using namespace std;
using namespace stdext;
hash_map<int, string> hm1;
typedef pair<int, string> is1(1, "a");
hm1.emplace(move(is1));
cout << "After the emplace insertion, hm1 contains:" << endl
<< " " << hm1.begin()->first
<< " => " << hm1.begin()->second
<< endl;
}
After the emplace insertion, hm1 contains:
1 => a
hash_map::emplace_hint
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Insere um elemento construído adequadamente em um hash_map
, com uma dica de posicionamento.
template <class ValTy>
iterator emplace_hint(
const_iterator _Where,
ValTy&& val);
Parâmetros
val
O valor usado para construir um elemento a ser inserido no hash_map
, a menos que o hash_map
já contenha o elemento (ou, de modo geral, um elemento cuja chave seja ordenada de maneira equivalente).
c
Uma dica relacionada ao local do qual se começa a procurar pelo ponto de inserção correto.
Valor de retorno
A função de membro hash_multimap::emplace
retorna um iterador que aponta para a posição em que o novo elemento foi inserido no hash_map
ou em que o elemento existente com uma ordenação equivalente está localizado.
Comentários
O hash_map::value_type
de um elemento é um par, de forma que o valor de um elemento será um par ordenado com o primeiro componente igual ao valor de chave e o segundo componente igual ao valor dos dados do elemento.
A inserção poderá ocorrer em um tempo constante amortizado, em vez de no tempo logarítmico, se o ponto de inserção seguir _Where
imediatamente.
Exemplo
// hash_map_emplace_hint.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>
int main()
{
using namespace std;
using namespace stdext;
hash_map<int, string> hm1;
typedef pair<int, string> is1(1, "a");
hm1.emplace(hm1.begin(), move(is1));
cout << "After the emplace, hm1 contains:" << endl
<< " " << hm1.begin()->first
<< " => " << hm1.begin()->second
<< endl;
}
After the emplace insertion, hm1 contains:
1 => a
hash_map::empty
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Testa se hash_map
está vazio.
bool empty() const;
Valor de retorno
true
se hash_map
for vazio; false
se hash_map
não for vazio.
Comentários
Exemplo
// hash_map_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1, hm2;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 1 ) );
if ( hm1.empty( ) )
cout << "The hash_map hm1 is empty." << endl;
else
cout << "The hash_map hm1 is not empty." << endl;
if ( hm2.empty( ) )
cout << "The hash_map hm2 is empty." << endl;
else
cout << "The hash_map hm2 is not empty." << endl;
}
The hash_map hm1 is not empty.
The hash_map hm2 is empty.
hash_map::end
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador que trata o local após o último elemento em um hash_map
.
const_iterator end() const;
iterator end();
Valor de retorno
Retorna um iterador bidirecional que trata o local após o último elemento em um hash_map
. Se o hash_map
estiver vazio, então hash_map::end == hash_map::begin
.
Comentários
end
é usado para testar se um iterador atingiu o fim de seu hash_map
.
O valor retornado por end
não deve ser desreferenciado.
Exemplo
// hash_map_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: iterator hm1_Iter;
hash_map <int, int> :: const_iterator hm1_cIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_cIter = hm1.end( );
hm1_cIter--;
cout << "The value of last element of hm1 is "
<< hm1_cIter -> second << "." << endl;
hm1_Iter = hm1.end( );
hm1_Iter--;
hm1.erase ( hm1_Iter );
// The following 2 lines would err because the iterator is const
// hm1_cIter = hm1.end ( );
// hm1_cIter--;
// hm1.erase ( hm1_cIter );
hm1_cIter = hm1.end( );
hm1_cIter--;
cout << "The value of last element of hm1 is now "
<< hm1_cIter -> second << "." << endl;
}
The value of last element of hm1 is 30.
The value of last element of hm1 is now 20.
hash_map::equal_range
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um par de iteradores, respectivamente, para o primeiro elemento em um hash_map
com uma chave que é maior do que uma chave especificada e para o primeiro elemento no hash_map
com uma chave igual ou maior que a chave.
pair <const_iterator, const_iterator> equal_range (const Key& key) const;
pair <iterator, iterator> equal_range (const Key& key);
Parâmetros
key
O valor de chave do argumento a ser comparado com a chave de classificação de um elemento do hash_map
que está sendo pesquisado.
Valor de retorno
Um par de iteradores em que o primeiro é o lower_bound
da chave e o segundo é o upper_bound
da chave.
Para acessar o primeiro iterador de um par pr
retornado pela função membro, use pr.first
e para desreferenciar o iterador de limite inferior, use *(pr.first)
. Para acessar o segundo iterador de um par pr
retornado pela função membro, use pr.second
e para desreferenciar o iterador de limite inferior, use *(pr.second)
.
Comentários
Exemplo
// hash_map_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
typedef hash_map <int, int> IntMap;
IntMap hm1;
hash_map <int, int> :: const_iterator hm1_RcIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
p1 = hm1.equal_range( 2 );
cout << "The lower bound of the element with "
<< "a key of 2 in the hash_map hm1 is: "
<< p1.first -> second << "." << endl;
cout << "The upper bound of the element with "
<< "a key of 2 in the hash_map hm1 is: "
<< p1.second -> second << "." << endl;
// Compare the upper_bound called directly
hm1_RcIter = hm1.upper_bound( 2 );
cout << "A direct call of upper_bound( 2 ) gives "
<< hm1_RcIter -> second << "," << endl
<< "matching the 2nd element of the pair"
<< " returned by equal_range( 2 )." << endl;
p2 = hm1.equal_range( 4 );
// If no match is found for the key,
// both elements of the pair return end( )
if ( ( p2.first == hm1.end( ) ) && ( p2.second == hm1.end( ) ) )
cout << "The hash_map hm1 doesn't have an element "
<< "with a key less than 40." << endl;
else
cout << "The element of hash_map hm1 with a key >= 40 is: "
<< p1.first -> first << "." << endl;
}
The lower bound of the element with a key of 2 in the hash_map hm1 is: 20.
The upper bound of the element with a key of 2 in the hash_map hm1 is: 30.
A direct call of upper_bound( 2 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 2 ).
The hash_map hm1 doesn't have an element with a key less than 40.
hash_map::erase
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Remove um elemento ou um intervalo de elementos em um hash_map
das posições especificadas ou remove elementos que correspondem a uma chave especificada.
iterator erase(iterator _Where);
iterator erase(iterator first, iterator last);
size_type erase(const key_type& key);
Parâmetros
_Where
Posição do elemento a ser removido de hash_map
.
first
Posição do primeiro elemento removido de hash_map
.
last
Posição além do último elemento removido de hash_map
.
key
O valor de chave dos elementos a serem removidos do hash_map
.
Valor de retorno
Para as duas primeiras funções membro, um iterador bidirecional que designa o primeiro elemento restante além de qualquer elemento removido ou um ponteiro para o final do hash_map
, se não houver tal elemento.
Para a terceira função membro, ele retorna o número de elementos que foram removidos do hash_map
.
Comentários
As funções membro nunca geram uma exceção.
Exemplo
O exemplo a seguir demonstra o uso da função de membro hash_map::erase
.
// hash_map_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main()
{
using namespace std;
using namespace stdext;
hash_map<int, int> hm1, hm2, hm3;
hash_map<int, int> :: iterator pIter, Iter1, Iter2;
int i;
hash_map<int, int>::size_type n;
typedef pair<int, int> Int_Pair;
for (i = 1; i < 5; i++)
{
hm1.insert(Int_Pair (i, i));
hm2.insert(Int_Pair (i, i*i));
hm3.insert(Int_Pair (i, i-1));
}
// The 1st member function removes an element at a given position
Iter1 = ++hm1.begin();
hm1.erase(Iter1);
cout << "After the 2nd element is deleted, the hash_map hm1 is:";
for (pIter = hm1.begin(); pIter != hm1.end(); pIter++)
cout << " " << pIter -> second;
cout << "." << endl;
// The 2nd member function removes elements
// in the range [ first, last)
Iter1 = ++hm2.begin();
Iter2 = --hm2.end();
hm2.erase(Iter1, Iter2);
cout << "After the middle two elements are deleted, "
<< "the hash_map hm2 is:";
for (pIter = hm2.begin(); pIter != hm2.end(); pIter++)
cout << " " << pIter -> second;
cout << "." << endl;
// The 3rd member function removes elements with a given key
n = hm3.erase(2);
cout << "After the element with a key of 2 is deleted,\n"
<< "the hash_map hm3 is:";
for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
cout << " " << pIter -> second;
cout << "." << endl;
// The 3rd member function returns the number of elements removed
cout << "The number of elements removed from hm3 is: "
<< n << "." << endl;
// The dereferenced iterator can also be used to specify a key
Iter1 = ++hm3.begin();
hm3.erase(Iter1);
cout << "After another element with a key equal to that"
<< endl;
cout << "of the 2nd element is deleted, "
<< "the hash_map hm3 is:";
for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
cout << " " << pIter -> second;
cout << "." << endl;
}
After the 2nd element is deleted, the hash_map hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_map hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_map hm3 is: 0 2 3.
The number of elements removed from hm3 is: 1.
After another element with a key equal to that
of the 2nd element is deleted, the hash_map hm3 is: 0 3.
hash_map::find
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador que trata do local de um elemento em um hash_map
que tem uma chave equivalente a uma chave especificada.
iterator find(const Key& key);
const_iterator find(const Key& key) const;
Parâmetros
key
O valor da chave a ser correspondido pela chave de classificação de um elemento do hash_map
que está sendo pesquisado.
Valor de retorno
Um iterador que trata do local de um elemento com uma chave especificada ou do local que sucede o último elemento no hash_map
se nenhuma correspondência for encontrada para a chave.
Comentários
find
retorna um iterador que trata de um elemento no hash_map
, cuja chave de classificação é equivalente à chave de argumento em um predicado binário que induz uma ordenação com base em uma relação de comparação do tipo "menor que".
Se o valor retornado de find
for atribuído a um const_iterator
, o objeto hash_map
não poderá ser modificado. Se o valor retornado de find
for atribuído a um iterator
, o objeto hash_map
poderá ser modificado
Exemplo
// hash_map_find.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_RcIter = hm1.find( 2 );
cout << "The element of hash_map hm1 with a key of 2 is: "
<< hm1_RcIter -> second << "." << endl;
// If no match is found for the key, end( ) is returned
hm1_RcIter = hm1.find( 4 );
if ( hm1_RcIter == hm1.end( ) )
cout << "The hash_map hm1 doesn't have an element "
<< "with a key of 4." << endl;
else
cout << "The element of hash_map hm1 with a key of 4 is: "
<< hm1_RcIter -> second << "." << endl;
// The element at a specific location in the hash_map can be found
// using a dereferenced iterator addressing the location
hm1_AcIter = hm1.end( );
hm1_AcIter--;
hm1_RcIter = hm1.find( hm1_AcIter -> first );
cout << "The element of hm1 with a key matching "
<< "that of the last element is: "
<< hm1_RcIter -> second << "." << endl;
}
The element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.
hash_map::get_allocator
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna uma cópia do objeto alocador usado para construir o hash_map
.
Allocator get_allocator() const;
Valor de retorno
O alocador usado pelo hash_map
.
Comentários
Alocadores para a classe hash_map
especificam como a classe gerencia o armazenamento. Os alocadores padrão fornecidos com as classes de contêiner da Biblioteca Padrão C++ são suficientes para a maioria das necessidades de programação. Gravando e usando sua própria classe de alocador é um tópico avançado do C++.
Exemplo
// hash_map_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int>::allocator_type hm1_Alloc;
hash_map <int, int>::allocator_type hm2_Alloc;
hash_map <int, double>::allocator_type hm3_Alloc;
hash_map <int, int>::allocator_type hm4_Alloc;
// The following lines declare objects
// that use the default allocator.
hash_map <int, int> hm1;
hash_map <int, int> hm2;
hash_map <int, double> hm3;
hm1_Alloc = hm1.get_allocator( );
hm2_Alloc = hm2.get_allocator( );
hm3_Alloc = hm3.get_allocator( );
cout << "The number of integers that can be allocated"
<< endl << "before free memory is exhausted: "
<< hm2.max_size( ) << "." << endl;
cout << "The number of doubles that can be allocated"
<< endl << "before free memory is exhausted: "
<< hm3.max_size( ) << "." << endl;
// The following line creates a hash_map hm4
// with the allocator of hash_map hm1.
hash_map <int, int> hm4( less<int>( ), hm1_Alloc );
hm4_Alloc = hm4.get_allocator( );
// Two allocators are interchangeable if
// storage allocated from each can be
// deallocated with the other
if( hm1_Alloc == hm4_Alloc )
{
cout << "The allocators are interchangeable."
<< endl;
}
else
{
cout << "The allocators are not interchangeable."
<< endl;
}
}
hash_map::hash_map
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Constrói um hash_map
que está vazio ou que é uma cópia de todo ou parte de algum outro hash_map
.
hash_map();
explicit hash_map(
const Traits& Comp);
hash_map(
const Traits& Comp,
const Allocator& Al);
hash_map(
const hash_map& Right);
hash_map(
hash_map&& Right);
hash_map(
initializer_list<Type> IList);hash_map(initializer_list<Type> IList,
const key_compare& Comp);
hash_map(
initializer_list<Type> IList,
const key_compare& Comp,
const allocator_type& Al);
template <class InputIterator>
hash_map(
InputIterator First,
InputIterator Last);
template <class InputIterator>
hash_map(
InputIterator First,
InputIterator Last,
const Traits& Comp);
template <class InputIterator>
hash_map(
InputIterator First,
InputIterator Last,
const Traits& Comp,
const Allocator& Al
Parâmetros
Al
A classe do alocador de armazenamento a ser usado para este objeto hash_map
, cujo padrão é Allocator
.
Comp
A função de comparação do tipo const Traits
usada para ordenar os elementos no hash_map
, cujo padrão é hash_compare
.
Right
O hash_map
do qual o mapa construído é uma cópia.
First
A posição do primeiro elemento no intervalo de elementos a serem copiados.
Last
A posição do primeiro elemento além do intervalo de elementos a serem copiados.
IList
O initializer_list
Comentários
Todos os construtores armazenam um tipo de objeto de alocador que gerencia o armazenamento de memória para a hash_map
e que, posteriormente, pode ser retornado ao chamar get_allocator
. O parâmetro do alocador muitas vezes é omitido nas declarações de classe e nas macros de pré-processamento usadas para substituir os alocadores alternativos.
Todos os construtores inicializam seu hash_map
.
Todos os construtores armazenam um objeto de função do tipo Traits
, que é usado para estabelecer uma ordem entre as chaves da hash_map
e que posteriormente pode ser retornado ao chamar key_comp
.
Os primeiros três construtores especificam um hash_map
inicial vazio, o segundo especifica o tipo de função de comparação (Comp
) a ser usada para estabelecer a ordem dos elementos e o terceiro especifica explicitamente o tipo de alocador (Al
) a ser usado. A palavra-chave explicit
suprime determinados tipos de conversão de tipo automática.
O quarto construtor especifica uma cópia do hash_map
Right
.
Os próximos três construtores copiam o intervalo [First, Last)
de um hash_map
com clareza crescente para especificar o tipo de função de comparação da classe Traits
e do alocador.
O último construtor move o hash_map
Right
.
hash_map::insert
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Insere um elemento ou um intervalo de elementos em um hash_map
.
pair <iterator, bool> insert(
const value_type& val);
iterator insert(
const_iterator _Where,
const value_type& val);
template <class InputIterator>
void insert(
InputIterator first,
InputIterator last);
template <class ValTy>
pair <iterator, bool>
insert(
ValTy&& val);
template <class ValTy>
iterator insert(
const_iterator _Where,
ValTy&& val);
Parâmetros
val
O valor de um elemento a ser inserido no hash_map
, a menos que o hash_map
já contenha o elemento ou, de modo geral (um elemento cuja chave seja ordenada de maneira equivalente).
_Where
Uma dica relacionada ao local do qual se começa a procurar pelo ponto de inserção correto.
first
A posição do primeiro elemento a ser copiado de um hash_map
.
last
A posição logo após o último elemento a ser copiado de um hash_map
.
Valor de retorno
A primeira função membro insert
retorna um par cujo componente bool
retorna true
se uma inserção tiver sido feita e false
se o hash_map
já contivesse um elemento cuja chave tinha um valor equivalente na ordenação e cujo componente do iterador retorna o endereço em que um novo elemento foi inserido ou onde o elemento já estava localizado.
Para acessar o componente do iterador de um par pr
retornado por essa função membro, use pr.first
e, para desreferenciar, use (pr.first)
. Para acessar o componente bool
de um par pr
retornado por essa função membro, use pr.second
e, para desreferenciar, use \(pr.second)
.
A segunda função membro insert
, a versão de dica, retorna um iterador que aponta para a posição em que o novo elemento foi inserido no hash_map
.
As duas últimas funções de membro insert
se comportam da mesma forma que as duas primeiras, mas elas constroem o valor inserido.
Comentários
O value_type
de um elemento é um par, de forma que o valor de um elemento será um par ordenado com o primeiro componente igual ao valor de chave e o segundo componente igual ao valor dos dados do elemento.
A inserção poderá ocorrer em um tempo constante amortizado para a versão de dica da inserção, em vez de no tempo logarítmico, se o ponto de inserção seguir _Where
imediatamente.
A terceira função membro insere a sequência de valores de elemento em um hash_map
que corresponde a cada elemento tratado por um iterador no intervalo *[First, Last)*
de um conjunto especificado.
Exemplo
// hash_map_insert.cpp
// compile with: /EHsc
#include<hash_map>
#include<iostream>
#include <string>
int main()
{
using namespace std;
using namespace stdext;
hash_map<int, int>::iterator hm1_pIter, hm2_pIter;
hash_map<int, int> hm1, hm2;
typedef pair<int, int> Int_Pair;
hm1.insert(Int_Pair(1, 10));
hm1.insert(Int_Pair(2, 20));
hm1.insert(Int_Pair(3, 30));
hm1.insert(Int_Pair(4, 40));
cout << "The original elements (Key => Value) of hm1 are:";
for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
cout << endl << " " << hm1_pIter -> first << " => "
<< hm1_pIter->second;
cout << endl;
pair< hash_map<int,int>::iterator, bool > pr;
pr = hm1.insert(Int_Pair(1, 10));
if (pr.second == true)
{
cout << "The element 10 was inserted in hm1 successfully."
<< endl;
}
else
{
cout << "The element 10 already exists in hm1\n"
<< "with a key value of "
<< "((pr.first) -> first) = " << (pr.first)->first
<< "." << endl;
}
// The hint version of insert
hm1.insert(--hm1.end(), Int_Pair(5, 50));
cout << "After the insertions, the elements of hm1 are:";
for (hm1_pIter = hm1.begin(); hm1_pIter != hm1.end(); hm1_pIter++)
cout << endl << hm1_pIter -> first << " => "
<< hm1_pIter->second;
cout << endl;
hm2.insert(Int_Pair(10, 100));
// The templatized version inserting a range
hm2.insert( ++hm1.begin(), --hm1.end() );
cout << "After the insertions, the elements of hm2 are:";
for (hm2_pIter = hm2.begin(); hm2_pIter != hm2.end(); hm2_pIter++)
cout << endl << hm2_pIter -> first << " => "
<< hm2_pIter->second;
cout << endl;
// The templatized versions move constructing elements
hash_map<int, string> hm3, hm4;
pair<int, string> is1(1, "a"), is2(2, "b");
hm3.insert(move(is1));
cout << "After the move insertion, hm3 contains:" << endl
<< hm3.begin()->first
<< " => " << hm3.begin()->second
<< endl;
hm4.insert(hm4.begin(), move(is2));
cout << "After the move insertion, hm4 contains:" << endl
<< hm4.begin()->first
<< " => " << hm4.begin()->second
<< endl;
}
The original elements (Key => Value) of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
The element 10 already exists in hm1
with a key value of ((pr.first) -> first) = 1.
After the insertions, the elements of hm1 are:
1 => 10
2 => 20
3 => 30
4 => 40
5 => 50
After the insertions, the elements of hm2 are:
2 => 20
10 => 100
3 => 30
4 => 40
After the move insertion, hm3 contains:
1 => a
After the move insertion, hm4 contains:
2 => b
hash_map::iterator
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece um iterador bidirecional que pode ler ou modificar qualquer elemento em um hash_map
.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;
Comentários
O iterator
definido por hash_map
aponta para elementos que são objetos de value_type
, que são do tipo pair<const Key, Type>
, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.
Para desreferenciar um iterador nomeado Iter
que aponta para um elemento em um multimap, use o operador ->
.
Para acessar o valor de chave do elemento, use Iter->first
, que é equivalente a (*Iter).first
. Para acessar o valor dos dados mapeados do elemento, use Iter->second
, que é equivalente a (*Iter).second
.
Um tipo de iterator
pode ser usado para modificar o valor de um elemento.
Exemplo
Confira begin
, para ver um exemplo de como declarar e usar o iterator
.
hash_map::key_comp
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Recupera uma cópia do objeto de comparação usada para ordenar chaves em um hash_map
.
key_compare key_comp() const;
Valor de retorno
Retorna o objeto de função que um hash_map
usa para ordenar os seus elementos.
Comentários
O objeto armazenado define a função membro
bool operator( const Key& left, const Key&right );
que retorna true
se left
for precedente e não igual a right
na ordem de classificação.
Exemplo
// hash_map_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int, hash_compare<int, less<int> > > hm1;
hash_map <int, int, hash_compare<int, less<int> > >::key_compare
kc1 = hm1.key_comp( ) ;
// Operator stored in kc1 tests order & returns bool value
bool result1 = kc1( 2, 3 ) ;
if( result1 == true )
{
cout << "kc1( 2,3 ) returns value of true,"
<< "\n where kc1 is the function object of hm1"
<< " of type key_compare." << endl;
}
else
{
cout << "kc1( 2,3 ) returns value of false"
<< "\n where kc1 is the function object of hm1"
<< " of type key_compare." << endl;
}
hash_map <int, int, hash_compare<int, greater<int> > > hm2;
hash_map <int, int, hash_compare<int, greater<int> > >
::key_compare kc2 = hm2.key_comp( );
// Operator stored in kc2 tests order & returns bool value
bool result2 = kc2( 2, 3 ) ;
if( result2 == true )
{
cout << "kc2( 2,3 ) returns value of true,"
<< "\n where kc2 is the function object of hm2"
<< " of type key_compare." << endl;
}
else
{
cout << "kc2( 2,3 ) returns value of false,"
<< "\n where kc2 is the function object of hm2"
<< " of type key_compare." << endl;
}
}
hash_map::key_compare
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece um objeto de função que pode comparar duas chaves de classificação para determinar a ordem relativa de dois elementos no mapa.
typedef Traits key_compare;
Comentários
key_compare
é um sinônimo do parâmetro de modelo Traits
.
Para obter mais informações sobre Traits
, confira o tópico hash_map
Classe.
Exemplo
Confira key_comp
, para ver um exemplo de como declarar e usar key_compare
.
hash_map::key_type
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que descreve o objeto de chave de classificação que constitui cada elemento do hash_map
.
typedef Key key_type;
Comentários
key_type
é um sinônimo do parâmetro de modelo Key
.
Para obter mais informações sobre Key
, consulte a seção Comentários do tópico hash_map
Classe .
Exemplo
Confira value_type
, para ver um exemplo de como declarar e usar key_type
.
hash_map::lower_bound
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador para o primeiro elemento em um hash_map
com um valor de chave que é igual ou maior que uma chave especificada.
iterator lower_bound(const Key& key);
const_iterator lower_bound(const Key& key) const;
Parâmetros
key
O valor de chave do argumento a ser comparado com a chave de classificação de um elemento do hash_map
que está sendo pesquisado.
Valor de retorno
Um iterator
ou const_iterator
que tratará a localização de um elemento em uma hash_map
com uma chave, que é igual ou maior que a chave de argumento ou que tratará o local após o último elemento na hash_map
se nenhuma correspondência for encontrada para a chave.
Se o valor retornado de lower_bound
for atribuído a um const_iterator
, o objeto hash_map
não poderá ser modificado. Se o valor retornado de lower_bound
for atribuído a um iterator
, o objeto hash_map
poderá ser modificado.
Comentários
Exemplo
// hash_map_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_RcIter = hm1.lower_bound( 2 );
cout << "The first element of hash_map hm1 with a key of 2 is: "
<< hm1_RcIter -> second << "." << endl;
// If no match is found for the key, end( ) is returned
hm1_RcIter = hm1. lower_bound ( 4 );
if ( hm1_RcIter == hm1.end( ) )
cout << "The hash_map hm1 doesn't have an element "
<< "with a key of 4." << endl;
else
cout << "The element of hash_map hm1 with a key of 4 is: "
<< hm1_RcIter -> second << "." << endl;
// An element at a specific location in the hash_map can be
// found using a dereferenced iterator addressing the location
hm1_AcIter = hm1.end( );
hm1_AcIter--;
hm1_RcIter = hm1. lower_bound ( hm1_AcIter -> first );
cout << "The element of hm1 with a key matching "
<< "that of the last element is: "
<< hm1_RcIter -> second << "." << endl;
}
The first element of hash_map hm1 with a key of 2 is: 20.
The hash_map hm1 doesn't have an element with a key of 4.
The element of hm1 with a key matching that of the last element is: 30.
hash_map::mapped_type
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que representa o tipo de dados armazenado em um hash_map
.
typedef Type mapped_type;
Comentários
O tipo mapped_type
é um sinônimo do parâmetro do modelo Type
.
Para obter mais informações sobre Type
, confira o tópico hash_map
Classe.
Exemplo
Confira value_type
, para ver um exemplo de como declarar e usar key_type
.
hash_map::max_size
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna o comprimento máximo do hash_map
.
size_type max_size() const;
Valor de retorno
O comprimento máximo possível da hash_map
.
Comentários
Exemplo
// hash_map_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: size_type i;
i = hm1.max_size( );
cout << "The maximum possible length "
<< "of the hash_map is " << i << "."
<< endl << "(Magnitude is machine specific.)";
}
hash_map::operator[]
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Insere um elemento em um hash_map
com um valor de chave especificado.
Type& operator[](const Key& key);
Type& operator[](Key&& key);
Parâmetros
key
O valor de chave do elemento a ser inserido.
Valor de retorno
Uma referência ao valor de dados do elemento inserido.
Comentários
Se o valor da chave do argumento não for encontrado, ele será inserido junto com o valor padrão do tipo de dados.
operator[]
pode ser usado para inserir elementos em um hash_map m
usando
m[ key] = DataValue
;
em que DataValue é o valor de mapped_type
do elemento com um valor de chave de key
.
Ao usar operator[]
para inserir elementos, a referência retornada não indica se uma inserção está alterando um elemento preexistente ou criando um novo. As funções membro find
e insert
podem ser usadas para determinar se um elemento com uma chave especificada já está presente antes de uma inserção.
Exemplo
// hash_map_op_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
#include <string>
int main( )
{
using namespace std;
using namespace stdext;
typedef pair <const int, int> cInt2Int;
hash_map <int, int> hm1;
hash_map <int, int> :: iterator pIter;
// Insert a data value of 10 with a key of 1
// into a hash_map using the operator[] member function
hm1[ 1 ] = 10;
// Compare other ways to insert objects into a hash_map
hm1.insert ( hash_map <int, int> :: value_type ( 2, 20 ) );
hm1.insert ( cInt2Int ( 3, 30 ) );
cout << "The keys of the mapped elements are:";
for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
cout << " " << pIter -> first;
cout << "." << endl;
cout << "The values of the mapped elements are:";
for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
cout << " " << pIter -> second;
cout << "." << endl;
// If the key already exists, operator[]
// changes the value of the datum in the element
hm1[ 2 ] = 40;
// operator[] will also insert the value of the data
// type's default constructor if the value is unspecified
hm1[5];
cout << "The keys of the mapped elements are now:";
for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
cout << " " << pIter -> first;
cout << "." << endl;
cout << "The values of the mapped elements are now:";
for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
cout << " " << pIter -> second;
cout << "." << endl;
// operator[] will also insert by moving a key
hash_map <string, int> hm2;
string str("a");
hm2[move(str)] = 1;
cout << "The moved key is " << hm2.begin()->first
<< ", with value " << hm2.begin()->second << endl;
}
hash_map::operator=
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Substitui os elementos do hash_map
por uma cópia de outro hash_map
.
hash_map& operator=(const hash_map& right);
hash_map& operator=(hash_map&& right);
Parâmetros
right
A classe right
que está sendo copiado no hash_map
.
Comentários
Após apagar os elementos existentes em um hash_map
, operator=
copiará ou moverá o conteúdo de right
para hash_map
.
Exemplo
// hash_map_operator_as.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map<int, int> v1, v2, v3;
hash_map<int, int>::iterator iter;
v1.insert(pair<int, int>(1, 10));
cout << "v1 = " ;
for (iter = v1.begin(); iter != v1.end(); iter++)
cout << iter->second << " ";
cout << endl;
v2 = v1;
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << iter->second << " ";
cout << endl;
// move v1 into v2
v2.clear();
v2 = move(v1);
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << iter->second << " ";
cout << endl;
}
hash_map::pointer
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece um ponteiro para um elemento em um hash_map
.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;
Comentários
Um tipo de pointer
pode ser usado para modificar o valor de um elemento.
Na maioria dos casos, um iterator
deve ser usado para acessar os elementos em um objeto hash_map
.
hash_map::rbegin
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador que trata o primeiro elemento em um hash_map
invertido.
const_reverse_iterator rbegin() const;
reverse_iterator rbegin();
Valor de retorno
Um iterador bidirecional constante invertido que aborda o primeiro elemento em uma hash_map
invertida ou abordando o que foi o último elemento na hash_map
não invertida.
Comentários
rbegin
é usado com um hash_map
invertido, assim como begin
é usado com um hash_map
.
Se o valor retornado de rbegin
for atribuído a uma const_reverse_iterator
, o objeto hash_map
não poderá ser modificado. Se o valor retornado de rbegin
for atribuído a uma reverse_iterator
, o objeto hash_map
não poderá ser modificado.
rbegin
pode ser usado para iterar em um hash_map
no sentido inverso.
Exemplo
// hash_map_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: iterator hm1_Iter;
hash_map <int, int> :: reverse_iterator hm1_rIter;
hash_map <int, int> :: const_reverse_iterator hm1_crIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_rIter = hm1.rbegin( );
cout << "The first element of the reversed hash_map hm1 is "
<< hm1_rIter -> first << "." << endl;
// begin can be used to start an iteration
// through a hash_map in a forward order
cout << "The hash_map is: ";
for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( ); hm1_Iter++)
cout << hm1_Iter -> first << " ";
cout << "." << endl;
// rbegin can be used to start an iteration
// through a hash_map in a reverse order
cout << "The reversed hash_map is: ";
for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
cout << hm1_rIter -> first << " ";
cout << "." << endl;
// A hash_map element can be erased by dereferencing to its key
hm1_rIter = hm1.rbegin( );
hm1.erase ( hm1_rIter -> first );
hm1_rIter = hm1.rbegin( );
cout << "After the erasure, the first element "
<< "in the reversed hash_map is "
<< hm1_rIter -> first << "." << endl;
}
The first element of the reversed hash_map hm1 is 3.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the first element in the reversed hash_map is 2.
hash_map::reference
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece uma referência a um elemento armazenado em um hash_map
.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;
Comentários
Exemplo
// hash_map_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
// Declare and initialize a const_reference &Ref1
// to the key of the first element
const int &Ref1 = ( hm1.begin( ) -> first );
// The following line would cause an error as the
// non-const_reference cannot be used to access the key
// int &Ref1 = ( hm1.begin( ) -> first );
cout << "The key of first element in the hash_map is "
<< Ref1 << "." << endl;
// Declare and initialize a reference &Ref2
// to the data value of the first element
int &Ref2 = ( hm1.begin( ) -> second );
cout << "The data value of first element in the hash_map is "
<< Ref2 << "." << endl;
// The non-const_reference can be used to modify the
// data value of the first element
Ref2 = Ref2 + 5;
cout << "The modified data value of first element is "
<< Ref2 << "." << endl;
}
The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The modified data value of first element is 15.
hash_map::rend
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador que trata o local após o último elemento em um hash_map
invertido.
const_reverse_iterator rend() const;
reverse_iterator rend();
Valor de retorno
Um iterador bidirecional inverso que aborda a localização que vem após o último elemento em uma hash_map
invertida (o local que precedeu o primeiro elemento no hash_map
não invertido).
Comentários
rend
é usado com um hash_map
invertido, assim como end
é usado com um hash_map
.
Se o valor retornado de rend
for atribuído a uma const_reverse_iterator
, o objeto hash_map
não poderá ser modificado. Se o valor retornado de rend
for atribuído a uma reverse_iterator
, o objeto hash_map
não poderá ser modificado.
rend
pode ser usado para testar se um iterador inverso alcançou o final de sua hash_map
.
O valor retornado por rend
não deve ser desreferenciado.
Exemplo
// hash_map_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: iterator hm1_Iter;
hash_map <int, int> :: reverse_iterator hm1_rIter;
hash_map <int, int> :: const_reverse_iterator hm1_crIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_rIter = hm1.rend( );
hm1_rIter--;
cout << "The last element of the reversed hash_map hm1 is "
<< hm1_rIter -> first << "." << endl;
// begin can be used to start an iteration
// through a hash_map in a forward order
cout << "The hash_map is: ";
for ( hm1_Iter = hm1.begin( ) ; hm1_Iter != hm1.end( );
hm1_Iter++)
cout << hm1_Iter -> first << " ";
cout << "." << endl;
// rbegin can be used to start an iteration
// through a hash_map in a reverse order
cout << "The reversed hash_map is: ";
for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( );
hm1_rIter++)
cout << hm1_rIter -> first << " ";
cout << "." << endl;
// A hash_map element can be erased by dereferencing to its key
hm1_rIter = --hm1.rend( );
hm1.erase ( hm1_rIter -> first );
hm1_rIter = hm1.rend( );
hm1_rIter--;
cout << "After the erasure, the last element "
<< "in the reversed hash_map is "
<< hm1_rIter -> first << "." << endl;
}
The last element of the reversed hash_map hm1 is 1.
The hash_map is: 1 2 3 .
The reversed hash_map is: 3 2 1 .
After the erasure, the last element in the reversed hash_map is 2.
hash_map::reverse_iterator
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que fornece um iterador bidirecional que pode ler ou modificar um elemento em um hash_map
invertido.
typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;
Comentários
Um tipo reverse_iterator
não pode modificar o valor de um elemento e é usado para iterar o hash_map
invertido.
O reverse_iterator
definido por hash_map
aponta para elementos que são objetos de value_type, que são do tipo pair<const Key, Type>
, cujo primeiro membro é a chave para o elemento e o segundo membro é a referência mapeada mantida pelo elemento.
Para desreferenciar um reverse_iterator
rIter
apontamento para um elemento em um hash_map
, use o ->
operador.
Para acessar o valor de chave do elemento, use rIter->first
, que é equivalente a (*rIter).first
. Para acessar o valor dos dados mapeados do elemento, use rIter->second
, que é equivalente a (*rIter).first
.
Exemplo
Confira rbegin
, para ver um exemplo de como declarar e usar reverse_iterator
.
hash_map::size
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna o número de elementos no hash_map
.
size_type size() const;
Valor de retorno
O comprimento atual do hash_map
.
Comentários
Exemplo
O exemplo a seguir demonstra o uso da função de membro hash_map::size
.
// hash_map_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map<int, int> hm1, hm2;
hash_map<int, int>::size_type i;
typedef pair<int, int> Int_Pair;
hm1.insert(Int_Pair(1, 1));
i = hm1.size();
cout << "The hash_map length is " << i << "." << endl;
hm1.insert(Int_Pair(2, 4));
i = hm1.size();
cout << "The hash_map length is now " << i << "." << endl;
}
The hash_map length is 1.
The hash_map length is now 2.
hash_map::size_type
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo de inteiro sem sinal que pode representar o número de elementos em um hash_map
.
typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;
Comentários
Exemplo
Confira size
, para ver um exemplo de como declarar e usar size_type
hash_map::swap
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Troca os elementos de dois hash_map
s.
void swap(hash_map& right);
Parâmetros
right
O argumento hash_map
que fornece os elementos a serem trocados com o destino hash_map
.
Comentários
A função membro não invalida nenhuma referência, ponteiro ou iterador que designa elementos nos dois hash_map
s cujos elementos estão sendo trocados.
Exemplo
// hash_map_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1, hm2, hm3;
hash_map <int, int>::iterator hm1_Iter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
hm2.insert ( Int_Pair ( 10, 100 ) );
hm2.insert ( Int_Pair ( 20, 200 ) );
hm3.insert ( Int_Pair ( 30, 300 ) );
cout << "The original hash_map hm1 is:";
for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
cout << " " << hm1_Iter -> second;
cout << "." << endl;
// This is the member function version of swap
// hm2 is said to be the argument hash_map;
// hm1 is said to be the target hash_map
hm1.swap( hm2 );
cout << "After swapping with hm2, hash_map hm1 is:";
for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
cout << " " << hm1_Iter -> second;
cout << "." << endl;
// This is the specialized template version of swap
swap( hm1, hm3 );
cout << "After swapping with hm3, hash_map hm1 is:";
for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
cout << " " << hm1_Iter -> second;
cout << "." << endl;
}
The original hash_map hm1 is: 10 20 30.
After swapping with hm2, hash_map hm1 is: 100 200.
After swapping with hm3, hash_map hm1 is: 300.
hash_map::upper_bound
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um iterador para o primeiro elemento em um hash_map
com uma chave cujo valor é maior que aquele de uma chave especificada.
iterator upper_bound(const Key& key);
const_iterator upper_bound(const Key& key) const;
Parâmetros
key
O valor de chave do argumento a ser comparado com o valor da chave de classificação de um elemento do hash_map
que está sendo pesquisado.
Valor de retorno
Um iterator
ou const_iterator
que tratará a localização de um elemento em um hash_map
com uma chave, que é maior que a chave de argumento ou que tratará o local após o último elemento no hash_map
se nenhuma correspondência for encontrada para a chave.
Se o valor retornado for atribuído a um const_iterator
, o objeto hash_map
não pode ser modificado. Se o valor retornado de for atribuído a iterator
, o objeto hash_map
poderá ser modificado.
Comentários
Exemplo
// hash_map_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int> hm1;
hash_map <int, int> :: const_iterator hm1_AcIter, hm1_RcIter;
typedef pair <int, int> Int_Pair;
hm1.insert ( Int_Pair ( 1, 10 ) );
hm1.insert ( Int_Pair ( 2, 20 ) );
hm1.insert ( Int_Pair ( 3, 30 ) );
hm1_RcIter = hm1.upper_bound( 2 );
cout << "The first element of hash_map hm1 with a key "
<< "greater than 2 is: "
<< hm1_RcIter -> second << "." << endl;
// If no match is found for the key, end is returned
hm1_RcIter = hm1. upper_bound ( 4 );
if ( hm1_RcIter == hm1.end( ) )
cout << "The hash_map hm1 doesn't have an element "
<< "with a key greater than 4." << endl;
else
cout << "The element of hash_map hm1 with a key > 4 is: "
<< hm1_RcIter -> second << "." << endl;
// The element at a specific location in the hash_map can be found
// using a dereferenced iterator addressing the location
hm1_AcIter = hm1.begin( );
hm1_RcIter = hm1. upper_bound ( hm1_AcIter -> first );
cout << "The 1st element of hm1 with a key greater than that\n"
<< "of the initial element of hm1 is: "
<< hm1_RcIter -> second << "." << endl;
}
The first element of hash_map hm1 with a key greater than 2 is: 30.
The hash_map hm1 doesn't have an element with a key greater than 4.
The 1st element of hm1 with a key greater than that
of the initial element of hm1 is: 20.
hash_map::value_comp
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Retorna um objeto de função que determina a ordem dos elementos em um hash_map
comparando os valores de chave.
value_compare value_comp() const;
Valor de retorno
Retorna o objeto da função de comparação que um hash_map
usa para ordenar os seus elementos.
Comentários
Para um hash_map
m
, se dois elementos e1
(k1
, d1
) e e2
(k2
, d2
) são objetos do tipo value_type
, onde k1
e k2
são suas chaves do tipo key_type
e d1
e são d2
seus dados do tipo mapped_type
, então m.value_comp()(e1, e2)
é equivalente a m.key_comp()(k1, k2)
. Um objeto armazenado define a função de membro
bool operator(value_type& left, value_type& right);
que retornará true
se o valor de chave left
for precedente e for diferente do valor de chave de right
na ordem de classificação.
Exemplo
// hash_map_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
hash_map <int, int, hash_compare<int, less<int> > > hm1;
hash_map <int, int, hash_compare<int, less<int> > >
::value_compare vc1 = hm1.value_comp( );
pair< hash_map<int,int>::iterator, bool > pr1, pr2;
pr1= hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
pr2= hm1.insert ( hash_map <int, int> :: value_type ( 2, 5 ) );
if( vc1( *pr1.first, *pr2.first ) == true )
{
cout << "The element ( 1,10 ) precedes the element ( 2,5 )."
<< endl;
}
else
{
cout << "The element ( 1,10 ) does not precede the element ( 2,5 )."
<< endl;
}
if( vc1 ( *pr2.first, *pr1.first ) == true )
{
cout << "The element ( 2,5 ) precedes the element ( 1,10 )."
<< endl;
}
else
{
cout << "The element ( 2,5 ) does not precede the element ( 1,10 )."
<< endl;
}
}
hash_map::value_type
Observação
Esta API está obsoleta. A alternativa é chamar a classe unordered_map
.
Um tipo que representa o tipo do objeto armazenado em um hash_map
.
typedef pair<const Key, Type> value_type;
Comentários
value_type
é declarado como pair<const key_type, mapped_type>
e não como pair<key_type, mapped_type>
porque as chaves de um contêiner associativo não podem ser alteradas usando uma referência ou iterador não constante.
Exemplo
// hash_map_value_type.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>
int main( )
{
using namespace std;
using namespace stdext;
typedef pair <const int, int> cInt2Int;
hash_map <int, int> hm1;
hash_map <int, int> :: key_type key1;
hash_map <int, int> :: mapped_type mapped1;
hash_map <int, int> :: value_type value1;
hash_map <int, int> :: iterator pIter;
// value_type can be used to pass the correct type
// explicitly to avoid implicit type conversion
hm1.insert ( hash_map <int, int> :: value_type ( 1, 10 ) );
// Compare other ways to insert objects into a hash_map
hm1.insert ( cInt2Int ( 2, 20 ) );
hm1[ 3 ] = 30;
// Initializing key1 and mapped1
key1 = ( hm1.begin( ) -> first );
mapped1 = ( hm1.begin( ) -> second );
cout << "The key of first element in the hash_map is "
<< key1 << "." << endl;
cout << "The data value of first element in the hash_map is "
<< mapped1 << "." << endl;
// The following line would cause an error because
// the value_type is not assignable
// value1 = cInt2Int ( 4, 40 );
cout << "The keys of the mapped elements are:";
for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
cout << " " << pIter -> first;
cout << "." << endl;
cout << "The values of the mapped elements are:";
for ( pIter = hm1.begin( ) ; pIter != hm1.end( ) ; pIter++ )
cout << " " << pIter -> second;
cout << "." << endl;
}
The key of first element in the hash_map is 1.
The data value of first element in the hash_map is 10.
The keys of the mapped elements are: 1 2 3.
The values of the mapped elements are: 10 20 30.
Confira também
Acesso Thread-Safe na Biblioteca Padrão C++
Referência da biblioteca padrão C++