unordered_multimap 클래스
클래스 템플릿은 형식 std::pair<const Key, Ty>요소의 다양한 길이 시퀀스를 제어하는 개체를 설명합니다. 시퀀스는 해시 함수로 약하게 정렬됩니다. 즉, 시퀀스를 버킷이라고 하는 하위 시퀀스의 정렬된 집합으로 분할합니다. 비교 함수는 각 버킷 내에서 요소 쌍이 동일하게 정렬되었는지 여부를 확인합니다. 각 요소는 두 개체, 정렬 키와 값을 저장합니다. 시퀀스는 최소한 모든 버킷이 대략 동일한 크기일 경우 시퀀스의 요소 수와 상관없이 작업 수를 사용하여 임의 요소를 조회, 삽입, 제거하는 방식으로 나타냅니다(일정 시간). 모든 요소가 하나의 버킷에 있는 최악의 경우에는 작업 수가 시퀀스의 요소 수에 비례합니다(선형 시간). 또한, 요소를 삽입할 경우 어떤 반복기도 무효화되지 않으며, 요소를 제거할 경우 제거된 요소를 가리키고 있는 반복기만 무효화됩니다.
구문
template <class Key,
class Ty,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multimap;
매개 변수
Key
키 형식입니다.
Ty
매핑된 형식입니다.
해시
해시 함수 개체 형식입니다.
Pred
같음 비교 함수 개체 형식입니다.
할당(Alloc)
할당자 클래스입니다.
멤버
| 형식 정의 | 설명 |
|---|---|
| allocator_type | 스토리지 관리를 위한 할당자의 형식입니다. |
| const_iterator | 제어되는 시퀀스에 대한 상수 반복기의 형식입니다. |
| const_local_iterator | 제어되는 시퀀스에 대한 상수 버킷 반복기의 형식입니다. |
| const_pointer | 요소에 대한 상수 포인터의 형식입니다. |
| const_reference | 요소에 대한 상수 참조의 형식입니다. |
| difference_type | 두 요소 사이의 부호가 있는 거리의 형식입니다. |
| hasher | 해시 함수의 형식입니다. |
| iterator | 제어되는 시퀀스에 대한 반복기의 형식입니다. |
| key_equal | 비교 함수의 형식입니다. |
| key_type | 정렬 키의 형식입니다. |
| local_iterator | 제어되는 시퀀스에 대한 버킷 반복기의 형식입니다. |
| mapped_type | 각 키와 연결된 매핑된 값의 형식입니다. |
| pointer | 요소에 대한 포인터의 형식입니다. |
| reference | 요소에 대한 참조의 형식입니다. |
| size_type | 두 요소 사이의 부호가 없는 거리의 형식입니다. |
| value_type | 요소의 형식입니다. |
| 멤버 함수 | 설명 |
|---|---|
| begin | 제어되는 시퀀스의 시작을 지정합니다. |
| 통 | 키 값에 대한 버킷 개수를 가져옵니다. |
| bucket_count | 버킷 개수를 가져옵니다. |
| bucket_size | 버킷의 크기를 가져옵니다. |
| cbegin | 제어되는 시퀀스의 시작을 지정합니다. |
| cend | 제어되는 시퀀스의 끝을 지정합니다. |
| clear | 모든 요소를 제거합니다. |
| 에는 C++20이 포함되어 있습니다. | 에 지정된 키를 unordered_multimap가진 요소가 있는지 확인합니다. |
| count | 지정한 키와 일치하는 요소의 수를 찾습니다. |
| emplace | 생성된 요소를 추가합니다. |
| emplace_hint | 힌트와 함께 생성된 요소를 추가합니다. |
| empty | 요소가 있는지 여부를 테스트합니다. |
| end | 제어되는 시퀀스의 끝을 지정합니다. |
| equal_range | 지정된 키와 일치하는 범위를 찾습니다. |
| erase | 지정된 위치에 있는 요소를 제거합니다. |
| find | 지정된 키와 일치하는 요소를 찾습니다. |
| get_allocator | 저장된 할당자 개체를 가져옵니다. |
| hash_function | 저장된 해시 함수 개체를 가져옵니다. |
| insert | 요소를 추가합니다. |
| key_eq | 저장된 비교 함수 개체를 가져옵니다. |
| load_factor | 버킷당 평균 요소 수를 계산합니다. |
| max_bucket_count | 최대 버킷 개수를 가져옵니다. |
| max_load_factor | 버킷당 최대 요소 수를 가져오거나 설정합니다. |
| max_size | 제어되는 시퀀스의 최대 크기를 가져옵니다. |
| 재 탕 | 해시 테이블을 다시 빌드합니다. |
| size | 요소 수를 계산합니다. |
| swap | 두 컨테이너의 내용을 바꿉니다. |
| unordered_multimap | 컨테이너 개체를 만듭니다. |
| Operator | 설명 |
|---|---|
| unordered_multimap::operator= | 해시 테이블을 복사합니다. |
설명
개체는 저장된 두 개체, unordered_multimap::key_equal 형식의 비교 함수 개체, unordered_multimap::hasher 형식의 해시 함수 개체를 호출하여 제어하는 시퀀스를 정렬합니다. 첫 번째 저장된 개체는 구성원 함수 unordered_multimap::key_eq()를 호출하여 액세스하며, 두 번째 저장된 개체는 구성원 함수 unordered_multimap::hash_function()을 호출하여 액세스합니다. 특히 X 형식의 모든 값 Y 및 Key의 경우 두 인수 값이 순서 지정이 동일할 경우 호출 key_eq()(X, Y)에서 true를 반환하며, 호출 hash_function()(keyval)은 형식 size_t의 값 분포를 생성합니다. 클래스 템플릿 unordered_map 클래스와 달리 형식 unordered_multimap 의 개체는 제어되는 시퀀스의 두 요소에 대해 항상 false임을 보장 key_eq()(X, Y) 하지 않습니다. (키는 고유할 필요가 없습니다.)
개체는 또한 최대 로드 비율(버킷당 최대 평균 요소 수를 원하는 대로 지정)를 저장합니다. 요소를 삽입할 때 unordered_multimap::load_factor()에서 최대 로드 비율이 초과될 경우 컨테이너는 버킷 수를 증가시키고 필요에 따라 해시 테이블을 다시 빌드합니다.
제어된 시퀀스의 실제 요소 순서는 해시 함수, 비교 함수, 삽입 순서, 최대 로드 비율, 현재 버킷 수에 따라 달라집니다. 제어된 시퀀스의 요소 순서는 일반적으로 예측할 수 없습니다. 하지만 동일하게 정렬된 요소의 하위 집합은 제어된 시퀀스에서 항상 인접해 있습니다.
개체는 unordered_multimap::allocator_type 형식의 저장된 할당자 개체를 통해 제어하는 시퀀스에 대한 스토리지를 할당하고 해제합니다. 이러한 할당자 개체는 형식 allocator의 개체와 동일한 외부 인터페이스를 가져야 합니다. 컨테이너 개체를 할당하는 경우 저장된 할당자 개체는 복사되지 않습니다.
요구 사항
헤더:<unordered_map>
네임스페이스: std
unordered_multimap::allocator_type
스토리지 관리를 위한 할당자의 형식입니다.
typedef Alloc allocator_type;
설명
이 형식은 템플릿 매개 변수 Alloc의 동의어입니다.
예시
// std__unordered_map__unordered_multimap_allocator_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Mymap c1;
Mymap::allocator_type al = c1.get_allocator();
std::cout << "al == std::allocator() is "
<< std::boolalpha << (al == Myalloc()) << std::endl;
return (0);
}
al == std::allocator() is true
unordered_multimap::begin
제어되는 시퀀스 또는 버킷의 시작을 지정합니다.
iterator begin();
const_iterator begin() const;
local_iterator begin(size_type nbucket);
const_local_iterator begin(size_type nbucket) const;
매개 변수
nbucket
버킷 번호입니다.
설명
처음 두 개의 멤버 함수는 시퀀스의 첫 번째 요소(또는 빈 시퀀스의 끝 바로 다음)를 가리키는 정방향 반복기를 반환합니다. 마지막 두 멤버 함수는 버킷 nbucket의 첫 번째 요소(또는 빈 버킷의 끝 바로 너머)를 가리키는 정방향 반복기를 반환합니다.
예시
// std__unordered_map__unordered_multimap_begin.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect first two items " [c 3] [b 2]"
Mymap::iterator it2 = c1.begin();
std::cout << " [" << it2->first << ", " << it2->second << "]";
++it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2]
[a, 1]
unordered_multimap::bucket
키 값에 대한 버킷 개수를 가져옵니다.
size_type bucket(const Key& keyval) const;
매개 변수
keyval
매핑할 키 값입니다.
설명
멤버 함수는 현재 키 값 키 변수에 해당하는 버킷 번호를 반환합니다.
예시
// std__unordered_map__unordered_multimap_bucket.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display buckets for keys
Mymap::size_type bs = c1.bucket('a');
std::cout << "bucket('a') == " << bs << std::endl;
std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
<< std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1
unordered_multimap::bucket_count
버킷 개수를 가져옵니다.
size_type bucket_count() const;
설명
멤버 함수는 현재 버킷 수를 반환합니다.
예시
// std__unordered_map__unordered_multimap_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
unordered_multimap::bucket_size
버킷의 크기를 가져옵니다.
size_type bucket_size(size_type nbucket) const;
매개 변수
nbucket
버킷 번호입니다.
설명
멤버 함수는 버킷 번호 nbucket의 크기를 반환합니다.
예시
// std__unordered_map__unordered_multimap_bucket_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display buckets for keys
Mymap::size_type bs = c1.bucket('a');
std::cout << "bucket('a') == " << bs << std::endl;
std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
<< std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1
unordered_multimap::cbegin
범위의 첫 번째 요소를 주소 지정하는 const 반복기를 반환합니다.
const_iterator cbegin() const;
Return Value
범위의 첫 번째 요소 또는 빈 범위의 끝 바로 다음 위치를 가리키는 const 정방향 액세스 반복기입니다(빈 범위의 경우 cbegin() == cend()).
설명
cbegin 반환 값을 사용하여 범위의 요소를 수정할 수 없습니다.
begin() 멤버 함수 대신 이 멤버 함수를 사용하여 반환 값이 const_iterator임을 보장할 수 있습니다. 일반적으로 다음 예제와 같이 auto 형식 추론 키워드와 함께 사용합니다. 이 예제에서는 Container가 begin() 및 cbegin()를 지원하는 수정 가능(비const)한 컨테이너로 가정합니다.
auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator
unordered_multimap::cend
범위에서 마지막 요소 바로 다음의 위치를 주소 지정하는 const 반복기를 반환합니다.
const_iterator cend() const;
Return Value
범위 끝의 바로 다음을 가리키는 const 정방향 액세스 반복기입니다.
설명
cend는 반복기가 범위 끝을 통과했는지 여부를 테스트하는 데 사용됩니다.
end() 멤버 함수 대신 이 멤버 함수를 사용하여 반환 값이 const_iterator임을 보장할 수 있습니다. 일반적으로 다음 예제와 같이 auto 형식 추론 키워드와 함께 사용합니다. 이 예제에서는 Container가 end() 및 cend()를 지원하는 수정 가능(비const)한 컨테이너로 가정합니다.
auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator
cend에서 반환한 값은 역참조되지 않아야 합니다.
unordered_multimap::clear
모든 요소를 제거합니다.
void clear();
설명
멤버 함수는 unordered_multimap::erase( unordered_multimap::begin(), unordered_multimap::end를 호출합니다.())
예시
// std__unordered_map__unordered_multimap_clear.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::const_iterator
제어되는 시퀀스에 대한 상수 반복기의 형식입니다.
typedef T1 const_iterator;
설명
이 형식은 제어되는 시퀀스의 상수 정방향 반복기로 사용될 수 있는 개체를 설명합니다. 여기서는 구현에서 정의된 형식 T1의 동의어로 설명됩니다.
예시
// std__unordered_map__unordered_multimap_const_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::const_local_iterator
제어되는 시퀀스에 대한 상수 버킷 반복기의 형식입니다.
typedef T5 const_local_iterator;
설명
형식은 버킷의 상수 정방향 반복기로 사용될 수 있는 개체를 설명합니다. 여기서는 구현에서 정의된 형식 T5의 동의어로 설명됩니다.
예시
// std__unordered_map__unordered_multimap_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1]
unordered_multimap::const_pointer
요소에 대한 상수 포인터의 형식입니다.
typedef Alloc::const_pointer const_pointer;
설명
이 형식은 제어되는 시퀀스의 요소에 대한 상수 포인터로 사용될 수 있는 개체를 설명합니다.
예시
// std__unordered_map__unordered_multimap_const_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::const_pointer p = &*it;
std::cout << " [" << p->first << ", " << p->second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::const_reference
요소에 대한 상수 참조의 형식입니다.
typedef Alloc::const_reference const_reference;
설명
이 형식은 제어되는 시퀀스의 요소에 대한 상수 참조로 사용될 수 있는 개체를 설명합니다.
예시
// std__unordered_map__unordered_multimap_const_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::const_reference ref = *it;
std::cout << " [" << ref.first << ", " << ref.second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::contains
에 지정된 키를 unordered_multimap가진 요소가 있는지 확인합니다.
bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;
매개 변수
K
키의 형식입니다.
key
찾을 요소의 키 값입니다.
Return Value
true 컨테이너에 요소가 있으면 이고, false 그렇지 않으면.
설명
contains() 는 C++20의 새로운 기능입니다. 이 옵션을 사용하려면 /std:c++20 이상 컴파일러 옵션을 지정합니다.
template<class K> bool contains(const K& key) const 투명할 경우 key_compare 오버로드 확인에만 참여합니다.
예시
// Requires /std:c++20 or /std:c++latest
#include <unordered_map>
#include <iostream>
int main()
{
std::unordered_multimap<int, bool> theUnorderedMultimap = {{0, false}, {1,true}};
std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
std::cout << theUnorderedMultimap.contains(1) << '\n';
std::cout << theUnorderedMultimap.contains(2) << '\n';
return 0;
}
true
false
unordered_multimap::count
지정한 키와 일치하는 요소의 수를 찾습니다.
size_type count(const Key& keyval) const;
매개 변수
keyval
검색할 키 값입니다.
설명
구성원 함수는 unordered_multimap::equal_range(keyval)로 구분된 범위의 요소 수를 반환합니다.
예시
// std__unordered_map__unordered_multimap_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "count('A') == " << c1.count('A') << std::endl;
std::cout << "count('b') == " << c1.count('b') << std::endl;
std::cout << "count('C') == " << c1.count('C') << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
count('A') == 0
count('b') == 1
count('C') == 0
unordered_multimap::difference_type
두 요소 사이의 부호가 있는 거리의 형식입니다.
typedef T3 difference_type;
설명
부호 있는 정수 형식은 제어되는 시퀀스에서 두 요소의 주소 간 차이점을 나타낼 수 있는 개체를 설명합니다. 여기서는 구현에서 정의된 형식 T3의 동의어로 설명됩니다.
예시
// std__unordered_map__unordered_multimap_difference_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// compute positive difference
Mymap::difference_type diff = 0;
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
++diff;
std::cout << "end()-begin() == " << diff << std::endl;
// compute negative difference
diff = 0;
for (Mymap::const_iterator it = c1.end();
it != c1.begin(); --it)
--diff;
std::cout << "begin()-end() == " << diff << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
end()-begin() == 3
begin()-end() == -3
unordered_multimap::emplace
배치 힌트를 사용하여 생성된 요소를 제 위치에 삽입합니다. 복사 또는 이동 작업은 수행되지 않습니다.
template <class... Args>
iterator emplace(Args&&... args);
매개 변수
args
에 삽입할 요소를 생성하기 위해 전달된 인수입니다 unordered_multimap.
Return Value
새로 삽입된 요소에 대한 반복기입니다.
설명
이 함수는 컨테이너 요소에 대한 참조는 무효화하지 않지만 컨테이너에 대한 모든 반복기는 무효화할 수 있습니다.
요소의 value_type은 쌍이므로, 요소의 값은 첫 번째 구성 요소가 키 값과 동일하고 두 번째 구성 요소가 요소의 데이터 값과 동일한 정렬된 쌍입니다.
삽입 중에 예외가 throw되었으나 컨테이너의 해시 함수에서 발생하지 않은 경우에는 컨테이너가 수정되지 않습니다. 예외가 해시 함수에서 throw된 경우 결과는 정의되어 있지 않습니다.
코드 예제를 보려면 multimap::emplace를 참조하세요.
unordered_multimap::emplace_hint
배치 힌트를 사용하여 생성된 요소를 제 위치에 삽입합니다. 복사 또는 이동 작업은 수행되지 않습니다.
template <class... Args>
iterator emplace_hint(
const_iterator where,
Args&&... args);
매개 변수
args
unordered에 삽입할 요소를 생성하기 위해 전달되는 인수입니다.
where
올바른 삽입 지점 검색을 시작할 위치와 관련된 힌트입니다.
Return Value
새로 삽입된 요소에 대한 반복기입니다.
설명
이 함수는 컨테이너 요소에 대한 참조는 무효화하지 않지만 컨테이너에 대한 모든 반복기는 무효화할 수 있습니다.
삽입 중에 예외가 throw되었으나 컨테이너의 해시 함수에서 발생하지 않은 경우에는 컨테이너가 수정되지 않습니다. 예외가 해시 함수에서 throw된 경우 결과는 정의되어 있지 않습니다.
요소의 value_type은 쌍이므로, 요소의 값은 첫 번째 구성 요소가 키 값과 동일하고 두 번째 구성 요소가 요소의 데이터 값과 동일한 정렬된 쌍입니다.
코드 예제를 보려면 map::emplace_hint를 참조하세요.
unordered_multimap::empty
요소가 있는지 여부를 테스트합니다.
bool empty() const;
설명
멤버 함수는 빈 제어되는 시퀀스에 대해 true를 반환합니다.
예시
// std__unordered_map__unordered_multimap_empty.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::end
제어되는 시퀀스의 끝을 지정합니다.
iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;
매개 변수
nbucket
버킷 번호입니다.
설명
처음 두 멤버 함수는 시퀀스 끝의 바로 다음을 가리키는 정방향 반복기를 반환합니다. 마지막 두 멤버 함수는 버킷 nbucket의 끝 바로 너머를 가리키는 정방향 반복기를 반환합니다.
예시
// std__unordered_map__unordered_multimap_end.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect last two items " [a 1] [b 2]"
Mymap::iterator it2 = c1.end();
--it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
--it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.end(c1.bucket('a'));
--lit;
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1] [b, 2]
[a, 1]
unordered_multimap::equal_range
지정된 키와 일치하는 범위를 찾습니다.
std::pair<iterator, iterator>
equal_range(const Key& keyval);
std::pair<const_iterator, const_iterator>
equal_range(const Key& keyval) const;
매개 변수
keyval
검색할 키 값입니다.
설명
멤버 함수는 키와 동등한 순서를 갖는 [X.first, X.second) 제어되는 시퀀스의 요소만 구분하도록 반복기 X 쌍을 반환합니다. 이러한 요소가 없는 경우 두 반복기는 end()입니다.
예시
// std__unordered_map__unordered_multimap_equal_range.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display results of failed search
std::pair<Mymap::iterator, Mymap::iterator> pair1 =
c1.equal_range('x');
std::cout << "equal_range('x'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << " [" << pair1.first->first
<< ", " << pair1.first->second << "]";
std::cout << std::endl;
// display results of successful search
pair1 = c1.equal_range('b');
std::cout << "equal_range('b'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << " [" << pair1.first->first
<< ", " << pair1.first->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
equal_range('x'):
equal_range('b'): [b, 2]
unordered_multimap::erase
지정된 위치에서 unordered_multimap의 요소 또는 요소의 범위를 제거하거나 지정된 키와 일치하는 요소를 제거합니다.
iterator erase(
const_iterator Where);
iterator erase(
const_iterator First,
const_iterator Last);
size_type erase(
const key_type& Key);
매개 변수
Where
제거할 요소의 위치입니다.
첫째
제거할 첫 번째 요소의 위치입니다.
마지막
제거할 마지막 요소 바로 다음 위치입니다.
Key
제거할 요소의 키 값입니다.
Return Value
처음 두 멤버 함수의 경우 제거된 요소 뒤에 남은 첫 번째 요소 또는 이러한 요소가 없을 경우 map의 끝에 있는 요소를 지정하는 양방향 반복기입니다.
세 번째 구성원 함수의 경우 unordered_multimap에서 제거된 요소의 수를 반환합니다.
설명
코드 예제를 보려면 map::erase를 참조하세요.
unordered_multimap::find
지정된 키와 일치하는 요소를 찾습니다.
const_iterator find(const Key& keyval) const;
매개 변수
keyval
검색할 키 값입니다.
설명
구성원 함수는 unordered_multimap::equal_range(keyval).first를 반환합니다.
예시
// std__unordered_map__unordered_multimap_find.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// try to find and fail
std::cout << "find('A') == "
<< std::boolalpha << (c1.find('A') != c1.end()) << std::endl;
// try to find and succeed
Mymap::iterator it = c1.find('b');
std::cout << "find('b') == "
<< std::boolalpha << (it != c1.end())
<< ": [" << it->first << ", " << it->second << "]" << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
find('A') == false
find('b') == true: [b, 2]
unordered_multimap::get_allocator
저장된 할당자 개체를 가져옵니다.
Alloc get_allocator() const;
설명
멤버 함수는 저장된 할당자 개체를 반환합니다.
예시
// std__unordered_map__unordered_multimap_get_allocator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Mymap c1;
Mymap::allocator_type al = c1.get_allocator();
std::cout << "al == std::allocator() is "
<< std::boolalpha << (al == Myalloc()) << std::endl;
return (0);
}
al == std::allocator() is true
unordered_multimap::hash_function
저장된 해시 함수 개체를 가져옵니다.
Hash hash_function() const;
설명
멤버 함수는 저장된 해시 함수 개체를 반환합니다.
예시
// std__unordered_map__unordered_multimap_hash_function.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::hasher hfn = c1.hash_function();
std::cout << "hfn('a') == " << hfn('a') << std::endl;
std::cout << "hfn('b') == " << hfn('b') << std::endl;
return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086
unordered_multimap::hasher
해시 함수의 형식입니다.
typedef Hash hasher;
설명
이 형식은 템플릿 매개 변수 Hash의 동의어입니다.
예시
// std__unordered_map__unordered_multimap_hasher.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::hasher hfn = c1.hash_function();
std::cout << "hfn('a') == " << hfn('a') << std::endl;
std::cout << "hfn('b') == " << hfn('b') << std::endl;
return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086
unordered_multimap::insert
unordered_multimap에 요소 또는 요소의 범위를 삽입합니다.
// (1) single element
pair<iterator, bool> insert(
const value_type& Val);
// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
ValTy&& Val);
// (3) single element with hint
iterator insert(
const_iterator Where,
const value_type& Val);
// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
const_iterator Where,
ValTy&& Val);
// (5) range
template <class InputIterator>
void insert(
InputIterator First,
InputIterator Last);
// (6) initializer list
void insert(
initializer_list<value_type>
IList);
매개 변수
Val
unordered_multimap에 삽입할 요소의 값입니다.
Where
올바른 삽입 지점 검색을 시작할 위치입니다.
ValTy
unordered_multimap value_type 요소를 생성하는 데 사용할 수 있는 인수 형식을 지정하고 Val을 인수로 완벽하게 전달하는 템플릿 매개 변수입니다.
첫째
복사할 첫 번째 요소의 위치입니다.
마지막
복사할 마지막 요소 바로 다음 위치입니다.
InputIterator
value_type 개체를 생성하는 데 사용할 수 있는 형식의 요소를 가리키는 입력 반복기의 요구 사항을 충족하는 템플릿 함수 인수입니다.
IList
요소를 복사할 원본 initializer_list입니다.
Return Value
단일 요소 삽입 멤버 함수 (1) 및 (2)는 unordered_multimap에 새 요소를 삽입한 위치로 반복기를 반환합니다.
힌트가 있는 단일 요소 멤버 함수 (3) 및 (4)는 unordered_multimap에 새 요소를 삽입한 위치를 가리키는 반복기를 반환합니다.
설명
이 함수는 어떠한 포인터 또는 참조를 무효화하지 않지만 컨테이너에 대한 모든 반복기를 무효화할 수 있습니다.
요소를 하나만 삽입하는 중 예외가 throw되었으나 컨테이너의 해시 함수에서 발생하지 않은 경우에는 컨테이너의 상태가 수정되지 않습니다. 예외가 해시 함수에서 throw된 경우 결과는 정의되어 있지 않습니다. 여러 요소를 삽입하는 중 예외가 throw되면 컨테이너는 지정되지 않았으나 유효한 상태로 남아 있습니다.
컨테이너의 value_type은 컨테이너에 속한 typedef이고 map의 경우 map<K, V>::value_type은 pair<const K, V>입니다. 요소의 값은 첫 번째 구성 요소가 키 값과 동일하고 두 번째 구성 요소는 요소의 데이터 값과 동일한 정렬된 쌍입니다.
범위 멤버 함수(5)는 범위의 반복기 [First, Last)에서 주소가 지정된 각 요소에 해당하는 unordered_multimap 요소 값 시퀀스를 삽입하므로 Last 는 삽입되지 않습니다. 컨테이너 멤버 함수 end()는 컨테이너의 마지막 요소 바로 뒤에 있는 위치를 참조합니다. 예를 들어 m.insert(v.begin(), v.end()); 문은 v의 모든 요소를 m에 삽입합니다.
이니셜라이저 목록 구성원 함수 (6)은 initializer_list를 사용하여 요소를 unordered_multimap으로 복사합니다.
생성된 요소를 제 위치에 삽입하려면, 즉 복사 또는 이동 작업을 수행하지 않으려면 unordered_multimap::emplace 및 unordered_multimap::emplace_hint를 참조하세요.
코드 예제를 보려면 multimap::insert를 참조하세요.
unordered_multimap::iterator
제어되는 시퀀스에 대한 반복기의 형식입니다.
typedef T0 iterator;
설명
이 형식은 제어되는 시퀀스의 정방향 반복기로 사용될 수 있는 개체를 설명합니다. 여기서는 구현에서 정의된 형식 T0의 동의어로 설명됩니다.
예시
// std__unordered_map__unordered_multimap_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::key_eq
저장된 비교 함수 개체를 가져옵니다.
Pred key_eq() const;
설명
멤버 함수는 저장된 비교 함수 개체를 반환합니다.
예시
// std__unordered_map__unordered_multimap_key_eq.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::key_equal cmpfn = c1.key_eq();
std::cout << "cmpfn('a', 'a') == "
<< std::boolalpha << cmpfn('a', 'a') << std::endl;
std::cout << "cmpfn('a', 'b') == "
<< std::boolalpha << cmpfn('a', 'b') << std::endl;
return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false
unordered_multimap::key_equal
비교 함수의 형식입니다.
typedef Pred key_equal;
설명
이 형식은 템플릿 매개 변수 Pred의 동의어입니다.
예시
// std__unordered_map__unordered_multimap_key_equal.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::key_equal cmpfn = c1.key_eq();
std::cout << "cmpfn('a', 'a') == "
<< std::boolalpha << cmpfn('a', 'a') << std::endl;
std::cout << "cmpfn('a', 'b') == "
<< std::boolalpha << cmpfn('a', 'b') << std::endl;
return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false
unordered_multimap::key_type
정렬 키의 형식입니다.
typedef Key key_type;
설명
이 형식은 템플릿 매개 변수 Key의 동의어입니다.
예시
// std__unordered_map__unordered_multimap_key_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
unordered_multimap::load_factor
버킷당 평균 요소 수를 계산합니다.
float load_factor() const;
설명
구성원 함수는 (float)unordered_multimap::size() / (float)unordered_multimap::bucket_count()(버킷당 평균 요소 수)를 반환합니다.
예시
// std__unordered_map__unordered_multimap_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
unordered_multimap::local_iterator
버킷 반복기의 형식입니다.
typedef T4 local_iterator;
설명
형식은 버킷의 정방향 반복기로 사용될 수 있는 개체를 설명합니다. 여기서는 구현에서 정의된 형식 T4의 동의어로 설명됩니다.
예시
// std__unordered_map__unordered_multimap_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1]
unordered_multimap::mapped_type
각 키와 연결된 매핑된 값의 형식입니다.
typedef Ty mapped_type;
설명
이 형식은 템플릿 매개 변수 Ty의 동의어입니다.
예시
// std__unordered_map__unordered_multimap_mapped_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
unordered_multimap::max_bucket_count
최대 버킷 개수를 가져옵니다.
size_type max_bucket_count() const;
설명
멤버 함수는 현재 허용된 최대 버킷 개수를 반환합니다.
예시
// std__unordered_map__unordered_multimap_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
unordered_multimap::max_load_factor
버킷당 최대 요소 수를 가져오거나 설정합니다.
float max_load_factor() const;
void max_load_factor(float factor);
매개 변수
요소
새로운 최대 로드 비율입니다.
설명
첫 번째 멤버 함수는 저장된 최대 로드 비율을 반환합니다. 두 번째 멤버 함수는 저장된 최대 로드 팩터를 요소로 바꿉니다.
예시
// std__unordered_map__unordered_multimap_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_bucket_count() == "
<< c1.max_bucket_count() << std::endl;
std::cout << "max_load_factor() == "
<< c1.max_load_factor() << std::endl;
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1
unordered_multimap::max_size
제어되는 시퀀스의 최대 크기를 가져옵니다.
size_type max_size() const;
설명
멤버 함수는 개체가 제어할 수 있는 가장 긴 시퀀스의 길이를 반환합니다.
예시
// std__unordered_map__unordered_multimap_max_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
std::cout << "max_size() == " << c1.max_size() << std::endl;
return (0);
}
max_size() == 536870911
unordered_multimap::operator=
해시 테이블을 복사합니다.
unordered_multimap& operator=(const unordered_multimap& right);
unordered_multimap& operator=(unordered_multimap&& right);
매개 변수
right
에 unordered_multimap 복사되는 항목입니다 unordered_multimap.
설명
unordered_multimap operator= 기존 요소를 지우고 나면 오른쪽의 내용을 복사하거나 unordered_multimap 이동합니다.
예시
// unordered_multimap_operator_as.cpp
// compile with: /EHsc
#include <unordered_multimap>
#include <iostream>
int main( )
{
using namespace std;
unordered_multimap<int, int> v1, v2, v3;
unordered_multimap<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;
}
unordered_multimap::pointer
요소에 대한 포인터의 형식입니다.
typedef Alloc::pointer pointer;
설명
이 형식은 제어되는 시퀀스의 요소에 대한 포인터로 사용될 수 있는 개체를 설명합니다.
예시
// std__unordered_map__unordered_multimap_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::pointer p = &*it;
std::cout << " [" << p->first << ", " << p->second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::reference
요소에 대한 참조의 형식입니다.
typedef Alloc::reference reference;
설명
이 형식은 제어되는 시퀀스의 요소에 대한 참조로 사용될 수 있는 개체를 설명합니다.
예시
// std__unordered_map__unordered_multimap_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::reference ref = *it;
std::cout << " [" << ref.first << ", " << ref.second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::rehash
해시 테이블을 다시 빌드합니다.
void rehash(size_type nbuckets);
매개 변수
nbuckets
요청된 버킷 수입니다.
설명
멤버 함수는 버킷 수를 nbuckets 이상으로 변경하고 필요에 따라 해시 테이블을 다시 작성합니다.
예시
// std__unordered_map__unordered_multimap_rehash.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect current parameters
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
std::cout << std::endl;
// change max_load_factor and redisplay
c1.max_load_factor(0.10f);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
std::cout << std::endl;
// rehash and redisplay
c1.rehash(100);
std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
std::cout << "load_factor() == " << c1.load_factor() << std::endl;
std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1
bucket_count() == 128
load_factor() == 0.0234375
max_load_factor() == 0.1
unordered_multimap::size
요소 수를 계산합니다.
size_type size() const;
설명
멤버 함수는 제어되는 시퀀스의 길이를 반환합니다.
예시
// std__unordered_map__unordered_multimap_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// clear the container and reinspect
c1.clear();
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
std::cout << std::endl;
c1.insert(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::size_type
두 요소 사이의 부호가 없는 거리의 형식입니다.
typedef T2 size_type;
설명
부호 없는 정수 형식은 제어되는 시퀀스의 길이를 나타낼 수 있는 개체를 설명합니다. 여기서는 구현에서 정의된 형식 T2의 동의어로 설명됩니다.
예시
// std__unordered_map__unordered_multimap_size_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::size_type sz = c1.size();
std::cout << "size == " << sz << std::endl;
return (0);
}
size == 0
unordered_multimap::swap
두 컨테이너의 내용을 바꿉니다.
void swap(unordered_multimap& right);
매개 변수
right
교환할 컨테이너입니다.
설명
멤버 함수는 제어된 시퀀스를 오른쪽 간에 *this 교환합니다. unordered_multimap::get_allocator() == right.get_allocator()인 경우 일정 시간에 이 작업을 수행하고 Tr 형식의 저장된 특성 개체를 복사한 결과로만 예외를 throw하며 두 개의 제어되는 시퀀스에서 요소를 지정하는 참조, 포인터 또는 반복기를 무효화하지 않습니다. 그렇지 않으면 두 개의 제어되는 시퀀스에 있는 요소 수에 비례하여 많은 요소 할당 및 생성자 호출을 수행합니다.
예시
// std__unordered_map__unordered_multimap_swap.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
Mymap c2;
c2.insert(Mymap::value_type('d', 4));
c2.insert(Mymap::value_type('e', 5));
c2.insert(Mymap::value_type('f', 6));
c1.swap(c2);
// display contents " [f 6] [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
swap(c1, c2);
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
unordered_multimap::unordered_multimap
컨테이너 개체를 만듭니다.
unordered_multimap(
const unordered_multimap& Right);
explicit unordered_multimap(
size_type Bucket_count = N0,
const Hash& Hash = Hash(),
const Comp& Comp = Pred(),
const Allocator& Al = Alloc());
unordered_multimap(
unordered_multimap&& Right);
unordered_multimap(
initializer_list<Type> IList);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash,
const Key& Key);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash,
const Key& Key,
const Allocator& Al);
template <class InputIterator>
unordered_multimap(
InputIterator first,
InputIterator last,
size_type Bucket_count = N0,
const Hash& Hash = Hash(),
const Comp& Comp = Pred(),
const Allocator& Al = Alloc());
매개 변수
InputIterator
반복기 형식입니다.
Al
저장할 할당자 개체입니다.
광고
저장할 비교 함수 개체입니다.
해시
저장할 해시 함수 개체입니다.
Bucket_count
최소 버킷 수입니다.
오른쪽
복사할 컨테이너입니다.
IList
요소를 복사할 원본 initializer_list입니다.
설명
첫 번째 생성자는 Right로 제어되는 시퀀스의 복사본을 지정합니다. 두 번째 생성자는 빈 제어 시퀀스를 지정합니다. 세 번째 생성자입니다. 는 오른쪽으로 이동하여 시퀀스의 복사본을 지정합니다. 네 번째, 다섯 번째, 여섯 번째, 일곱 번째 및 여덟 번째 생성자는 멤버에 initializer_list를 사용합니다. 아홉 번째 생성자는 [First, Last) 요소 값의 시퀀스를 삽입합니다.
모든 생성자는 또한 여러 개의 저장된 값을 초기화합니다. 복사 생성자의 경우 오른쪽에서 값을 가져옵니다. 그렇지 않은 경우:
버킷의 최소 수는 Bucket_count 인수입니다(있는 경우). 그렇지 않으면 구현 정의 값으로 여기에 설명된 기본값N0입니다.
해시 함수 개체는 인수 해시(있는 경우)이고, 그렇지 않으면 .입니다 Hash().
비교 함수 개체는 인수 Comp(있는 경우)이고, 그렇지 않으면 Comp입니다 Pred().
할당자 개체는 인수 Al(있는 경우)이고, 그렇지 않으면 입니다Alloc().
예시
// std__unordered_map__unordered_multimap_construct.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
using namespace std;
using Mymap = unordered_multimap<char, int> ;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
Mymap c2(8,
hash<char>(),
equal_to<char>(),
allocator<pair<const char, int> >());
c2.insert(Mymap::value_type('d', 4));
c2.insert(Mymap::value_type('e', 5));
c2.insert(Mymap::value_type('f', 6));
// display contents " [f 6] [e 5] [d 4]"
for (const auto& c : c2) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
Mymap c3(c1.begin(),
c1.end(),
8,
hash<char>(),
equal_to<char>(),
allocator<pair<const char, int> >());
// display contents " [c 3] [b 2] [a 1]"
for (const auto& c : c3) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
Mymap c4(move(c3));
// display contents " [c 3] [b 2] [a 1]"
for (const auto& c : c4) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Construct with an initializer_list
unordered_multimap<int, char> c5({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } });
for (const auto& c : c5) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size
unordered_multimap<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size and hash
unordered_multimap<int, char, hash<char>> c7(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
hash<char>()
);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size, hash, and key_equal
unordered_multimap<int, char, hash<char>, equal_to<char>> c8(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
hash<char>(),
equal_to<char>()
);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size, hash, key_equal, and allocator
unordered_multimap<int, char, hash<char>, equal_to<char>> c9(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
hash<char>(),
equal_to<char>(),
allocator<pair<const char, int> >()
);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
}
[a, 1] [b, 2] [c, 3] [d, 4] [e, 5] [f, 6] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [5, g] [6, h] [7, i] [8, j] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2] [a, 1]
unordered_multimap::value_type
요소의 형식입니다.
typedef std::pair<const Key, Ty> value_type;
설명
형식은 제어되는 시퀀스의 요소를 설명합니다.
예시
// std__unordered_map__unordered_multimap_value_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]