hash_multimap 클래스

아티클
10/12/2023

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

컨테이너 클래스 hash_multimap은 C++ 표준 라이브러리의 확장이며, 각 요소가 값이 고유할 필요가 없는 정렬 키와 관련 데이터 값으로 구성된 쌍인 컬렉션에서 데이터를 스토리지하고 빠르게 검색하는 데 사용됩니다.

구문

template <class Key,
    class Type,
    class Traits=hash_compare <Key, less <Key>>,
    class Allocator=allocator <pair  <const Key, Type>>>
class hash_multimap

매개 변수

Key
hash_multimap에 저장되는 키 데이터 형식입니다.

Type
hash_multimap에 저장되는 요소 데이터 형식입니다.

특성
두 개의 함수 개체를 포함하는 형식으로, 두 요소 값을 정렬 키로 비교하여 상대 순서를 확인할 수 있는 클래스 Traits 와 요소의 단항 조건자 매핑 키 값인 해시 함수를 형식 size_t의 부호 없는 정수로 변환합니다. 이 인수는 선택 사항이며 기본값은 hash_compare<Key, less<Key>>입니다.

할당자
hash_multimap의 메모리 할당 및 할당 취소에 대한 세부 정보를 캡슐화하는 저장된 할당자 개체를 나타내는 형식입니다. 이 인수는 선택 사항이며 기본값은 allocator<pair <const Key, Type>>입니다.

설명

hash_multimap은 다음과 같습니다.

연관된 키 값을 기준으로 하며 요소 값의 효율적인 검색을 지원하는 가변 크기 컨테이너인 연관 컨테이너입니다.
이는 해당 요소에 액세스할 수 있는 양방향 반복기를 제공하기 때문에 되돌릴 수 있습니다.
요소가 요소의 키 값에 적용된 해시 함수 값을 기반으로 하여 버킷으로 그룹화되기 때문에 해시됩니다.
해당 요소는 고유 키를 가질 필요가 없기 때문에 복수이며, 하나의 키 값은 이와 연관된 많은 요소 데이터 값을 가질 수 있습니다.
요소 값은 키 값과 구별되기 때문에 쌍 연관 컨테이너입니다.
클래스 템플릿은 제공하는 기능이 일반적이고 요소 또는 키로 포함된 특정 데이터 형식과 독립적이기 때문입니다. 요소에 사용될 데이터 형식과 키는 대신 비교 함수 및 할당자와 함께 클래스 템플릿에서 매개 변수로 지정됩니다.

해시는 정렬보다 훨씬 효율적입니다. 성공적인 해시는 정렬 방식에 대한 컨테이너의 요소 수 로그에 비례하는 시간과 비교할 때 삽입, 삭제, 찾기를 일정한 평균 시간 이내에 수행합니다. hash_multimap 요소의 값은 연관된 키 값을 제외하고 직접적으로 변경할 수 있습니다. 대신, 이전 요소와 관련된 키 값을 삭제하고 새 요소와 연결된 새 키 값을 삽입해야 합니다.

컨테이너 형식은 일반적으로 애플리케이션에서 필요한 검색과 삽입의 형식을 기준으로 선택해야 합니다. 해시된 연관 컨테이너는 조회, 삽입 및 제거 작업에 최적화되어 있습니다. 명시적으로 이러한 작업을 지원하는 멤버 함수는 잘 설계된 해시 함수와 함께 사용할 경우 효율적이며, 컨테이너의 요소 수에 종속되지 않는 일정한 평균 시간으로 작업을 수행합니다. 잘 설계된 해시 함수는 해시된 값의 균일한 분포를 생성하고 충돌 수를 최소화합니다. 여기서 충돌은 특정 키 값이 동일한 해시된 값에 매핑될 때 발생합니다. 가능한 최악의 해시 함수가 있는 최악의 경우에는 작업 수가 시퀀스의 요소 수에 비례합니다(선형 시간).

애플리케이션에서 값과 해당 키를 연결하는 조건을 만족할 경우 적절한 연관 컨테이너는 hash_multimap입니다. 이 구조 형식의 모델은 단어들이 항상 유일하게 정의되지 않는 "정의" 같이 문자열 값과 연결된 키 단어들의 정렬된 목록입니다. 대신 키워드가 고유하게 정의되어 키가 고유한 경우 hash_map이 적절한 컨테이너가 됩니다. 반면에 단어 목록만 저장하는 경우에는 hash_set이 올바른 컨테이너가 됩니다. 단어를 여러 번 중복할 수 있는 경우 hash_multiset이 적절한 컨테이너 구조입니다.

hash_multimap은 value_compare 형식의 저장된 해시 Traits 개체를 호출하여 제어하는 시퀀스를 정렬합니다. 이 저장된 개체는 key_comp 멤버 함수를 호출하여 액세스할 수 있습니다. 이러한 함수 개체는 hash_compare<Key, less<Key>> 클래스의 개체와 동일하게 동작해야 합니다. 특히, Key 형식의 모든 값 Key에 대해 Traits (Key) 호출은 size_t 형식의 값 분포를 생성합니다.

일반적으로, 이 순서를 정하려면 요소의 크기를 비교할 수 있어야 합니다. 즉, 제공된 어떤 두 요소에서 두 요소가 동일하거나(어떤 것도 다른 것보다 작지 않음) 하나가 다른 것보다 작음을 정할 수 있어야 합니다. 그러면 동일하지 않은 요소 사이에 정렬이 수행됩니다. 기술적으로 설명하면, 비교 함수는 표준 함수의 의미에서 엄밀히 약한 정렬을 수행하는 이진 조건자입니다. 이진 조건자 f(x, y)는 두 인수 개체 x 및 y를 가지는 함수 개체이며, true 또는 false 값을 반환합니다. 이진 조건자가 비재귀적, 비대칭 및 전이적인 경우 및 동등성이 전이적인 경우 hash_multimap에 적용된 정렬은 엄밀히 약한 정렬입니다. 여기서, f(x, y) 및 f(y, x)가 모두 false인 경우 x 및 y 두 개체는 동등한 것으로 정의됩니다. 키 사이의 더 강력한 같음 조건이 동등 조건을 대체하는 경우, 정렬은 전체가 되고(모든 요소가 서로 상대적으로 정렬됨을 의미) 일치된 키는 서로 구분할 수 없게 됩니다.

제어된 시퀀스의 실제 요소 순서는 해시 함수, 순서 지정 함수 및 컨테이너 개체에 저장된 해시 테이블의 현재 크기에 따라 달라집니다. 해시 테이블의 현재 크기를 확인할 수 없으므로 제어된 시퀀스의 요소 순서는 일반적으로 예측할 수 없습니다. 요소를 삽입할 경우 어떤 반복기도 무효화되지 않으며, 요소를 제거할 경우 제거된 요소를 명확히 가리키고 있는 반복기만 무효화됩니다.

hash_multimap 클래스에서 제공하는 반복기는 양방향 반복기이지만, insert 및 hash_multimap 클래스 멤버 함수의 버전은 기능 요구 사항이 양방향 반복기 클래스에서 보장하는 것보다 최소화된 약한 입력 반복기를 템플릿 매개 변수로 사용합니다. 다른 반복기 개념은 관련된 상세 기능별로 범주를 구성합니다. 각 반복기 개념에는 요구 사항의 고유한 hash_multimap이 있으며, 이러한 요구 사항을 적용하는 알고리즘은 해당 반복기 형식이 제공하는 요구 사항으로 가정을 제한해야 합니다. 입력 반복기를 역참조하여 몇 가지 개체를 참조하고 시퀀스의 다음 반복기로 증가되는 경우를 가정할 수 있습니다. 이는 기능의 최소 hash_multimap이지만, 멤버 함수의 컨텍스트에서 반복기 범위 [First, Last)에 대해 설명하는 데에는 충분합니다.

생성자

생성자	Description
hash_multimap	특정 크기의 목록 또는 특정 값의 요소 또는 특정 `allocator`가 포함된 목록 또는 다른 `hash_multimap`의 복사본으로 생성합니다.

Typedef

형식 이름	설명
allocator_type	`allocator` 개체의 `hash_multimap` 클래스를 나타내는 형식입니다.
const_iterator	`const`에 있는 `hash_multimap` 요소를 읽을 수 있는 양방향 반복기를 제공하는 형식입니다.
const_pointer	`const`에 있는 `hash_multimap` 요소에 대한 포인터를 제공하는 형식입니다.
const_reference	`const` 작업을 읽고 수행하기 위해 `hash_multimap`에 저장된 `const` 요소에 대한 참조를 제공하는 형식입니다.
const_reverse_iterator	`const`에 있는 `hash_multimap` 요소를 읽을 수 있는 양방향 반복기를 제공하는 형식입니다.
difference_type	부호 있는 정수 형식은 반복기가 가리키는 요소 사이의 범위에 있는 `hash_multimap`의 요소의 개수를 표현하는 데 사용할 수 있습니다.
iterator	`hash_multimap`에 있는 모든 요소를 읽거나 수정할 수 있는 양방향 반복기를 제공하는 형식입니다.
key_compare	`hash_multimap`의 두 요소간 상대적 순서를 결정하는 두 정렬 키를 비교할 수 있는 함수 개체를 제공하는 형식입니다.
key_type	`hash_multimap`의 각 요소를 구성하는 정렬 키 개체를 설명하는 형식입니다.
mapped_type	`hash_multimap` 내에 저장된 데이터 형식을 나타내는 형식입니다.
pointer	`hash_multimap`의 요소에 대한 포인터를 제공하는 형식입니다.
reference	`hash_multimap` 내에 저장된 요소에 대한 참조를 제공하는 형식입니다.
reverse_iterator	역순 `hash_multimap`의 요소를 읽거나 수정할 수 있는 양방향 반복기를 제공하는 형식입니다.
size_type	`hash_multimap`에서 요소 수를 표현할 수 있는 부호 없는 정수 형식입니다.
value_type	두 요소를 정렬 키로 비교하여 `hash_multimap`에서 상대적 순서를 결정할 수 있는 함수 개체를 제공하는 형식입니다.

멤버 함수

멤버 함수	설명
begin	`hash_multimap`의 첫 번째 요소를 주소 지정하는 반복기를 반환합니다.
cbegin	`hash_multimap`의 첫 번째 요소를 주소 지정하는 상수 반복기를 반환합니다.
cend	`hash_multimap`에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 상수 반복기를 반환합니다.
clear	`hash_multimap`의 모든 요소를 지웁니다.
count	키가 매개 변수로 지정된 키와 일치하는 `hash_multimap`의 요소 수를 반환합니다.
crbegin	역순 `hash_multimap`에서 첫 번째 요소를 주소 지정하는 상수 반복기를 반환합니다.
crend	역순 `hash_multimap`에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 상수 반복기를 반환합니다.
emplace	생성된 요소를 `hash_multimap`에 삽입합니다.
emplace_hint	배치 힌트를 사용하여 생성된 요소를 `hash_multimap`에 삽입합니다.
empty	`hash_multimap`가 비어 있는지 여부를 테스트합니다.
end	`hash_multimap`에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 반복기를 반환합니다.
equal_range	`hash_multimap`에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 반복기를 반환합니다.
erase	`hash_multimap`의 지정된 위치에서 요소 또는 요소 범위를 제거합니다.
find	지정된 키와 같은 키를 가진 `hash_multimap` 내 요소의 위치를 가리키는 반복기를 반환합니다.
get_allocator	`allocator`을 생성하는 데 사용되는 `hash_multimap` 개체의 복사본을 반환합니다.
insert	요소 또는 요소의 범위를 `hash_multimap`의 지정된 위치에 삽입합니다.
key_comp	`hash_multimap`에서 키를 정렬하기 위해 사용하는 비교 개체의 복사본을 검색합니다.
lower_bound	`hash_multimap`에서 지정된 키보다 같거나 큰 키 값을 가진 첫 번째 요소에 반복기를 반환합니다.
max_size	`hash_multimap`의 최대 길이를 반환합니다.
rbegin	역순 `hash_multimap`에서 첫 번째 요소를 참조하는 반복기를 반환합니다.
rend	역순 `hash_multimap`에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 반복기를 반환합니다.
size	`hash_multimap`의 새 크기를 지정합니다.
swap	두 `hash_multimap`의 요소를 교환합니다.
upper_bound	`hash_multimap`에서 지정된 키보다 큰 키 값을 가진 첫 번째 요소에 반복기를 반환합니다.
value_comp	`hash_multimap`에서 요소 값의 정렬에 사용되는 비교 개체의 복사본을 검색합니다.

연산자

연산자	설명
hash_multimap::operator=	`hash_multimap`의 요소를 다른 `hash_multimap`의 복사본으로 대체합니다.

요구 사항

헤더:<hash_map>

네임스페이스: stdext

hash_multimap::allocator_type

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap 개체의 할당자 클래스를 나타내는 형식입니다.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::allocator_type allocator_type;

설명

allocator_type은 템플릿 매개 변수 Allocator의 동의어입니다.

Allocator에 대한 자세한 내용은 hash_multimap 클래스 항목의 설명 섹션을 참조하세요.

예시

allocator_type을 사용하는 예제는 get_allocator의 예제를 참조하세요.

hash_multimap::begin

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap의 첫 번째 요소 주소를 지정하는 반복기를 반환합니다.

const_iterator begin() const;

iterator begin();

Return Value

hash_multimap의 첫 번째 요소 또는 빈 hash_multimap 다음의 위치 주소를 지정하는 양방향 반복기입니다.

설명

반환 값 begin 이 할당 const_iterator된 경우 hash_multimap 개체의 요소를 수정할 수 없습니다. 반환 값 begin 이 할당 iterator된 경우 hash_multimap 개체의 요소를 수정할 수 있습니다.

예시

// hash_multimap_begin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <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_multimap::cbegin

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap의 첫 번째 요소 주소를 지정하는 상수 반복기를 반환합니다.

const_iterator cbegin() const;

Return Value

hash_multimap의 첫 번째 요소 또는 빈 hash_multimap 다음의 위치 주소를 지정하는 상수 양방향 반복기입니다.

예시

// hash_multimap_cbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <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_multimap::cend

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 상수 반복기를 반환합니다.

const_iterator cend() const;

Return Value

hash_multimap에서 마지막 요소 다음에 나오는 위치의 주소를 지정하는 상수 양방향 반복기입니다. hash_multimap이 비어 있으면 hash_multimap::cend == hash_multimap::begin입니다.

설명

cend는 반복기가 hash_multimap의 끝에 도달했는지 여부를 테스트하는 데 사용됩니다.

cend에서 반환한 값은 역참조되지 않아야 합니다.

예시

// hash_multimap_cend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <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_multimap::clear

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap의 모든 요소를 지웁니다.

void clear();

설명

예시

다음 예제에서는 hash_multimap::clear 멤버 함수의 사용을 보여 줍니다.

// hash_multimap_clear.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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_multimap is initially "
         << i  << "." << endl;

    hm1.clear();
    i = hm1.size();
    cout << "The size of the hash_multimap after clearing is "
         << i << "." << endl;
}

The size of the hash_multimap is initially 2.
The size of the hash_multimap after clearing is 0.

hash_multimap::const_iterator

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap 요소를 읽을 const 수 있는 양방향 반복기를 제공하는 형식입니다.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_iterator const_iterator;

설명

const_iterator 형식을 사용하여 요소의 값을 수정할 수는 없습니다.

hash_multimap 정의된 것은 const_iterator 형식pair<const Key, Type>인 value_type 개체를 가리킵니다. 키의 값은 첫 번째 멤버 쌍을 통해 제공되며 매핑된 요소의 값은 쌍의 두 번째 멤버를 통해 제공됩니다.

hash_multimap 요소에 대한 포인팅을 역참조 const_iterator cIter 하려면 연산자를 -> 사용합니다.

요소에 대한 키 값에 액세스하려면 해당(*cIter).first되는 키를 사용합니다cIter->first. 요소에 대해 매핑된 데이텀의 값에 액세스하려면 해당(*cIter).second되는 를 사용합니다cIter->second.

예시

const_iterator를 사용하는 예제는 begin의 예제를 참조하세요.

hash_multimap::const_pointer

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap 요소에 대한 포인터를 const 제공하는 형식입니다.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_pointer const_pointer;

설명

const_pointer 형식을 사용하여 요소의 값을 수정할 수는 없습니다.

대부분의 경우 iterator를 사용하여 hash_multimap 개체의 요소에 액세스해야 합니다.

hash_multimap::const_reference

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

작업을 읽고 수행하기 const 위해 const hash_multimap 저장된 요소에 대한 참조를 제공하는 형식입니다.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::const_reference const_reference;

설명

예시

// hash_multimap_const_ref.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<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 first element in the hash_multimap 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 1st element in the hash_multimap is "
        << Ref2 << "." << endl;
}

The key of first element in the hash_multimap is 1.
The data value of 1st element in the hash_multimap is 10.

hash_multimap::const_reverse_iterator

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap 요소를 const 읽을 수 있는 양방향 반복기를 제공하는 형식입니다.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::const_reverse_iterator const_reverse_iterator;

설명

const_reverse_iterator 형식은 요소 값을 수정할 수 없으며 hash_multimap을 역방향으로 반복하는 데 사용됩니다.

hash_multimap 정의된 value_type const_reverse_iterator 개체를 가리킵니다. 즉, 첫 번째 멤버는 요소의 키이고 두 번째 멤버는 요소가 보유한 매핑된 데이텀인 형식pair<const Key, Type>입니다.

hash_multimap 요소에 대한 포인팅을 역참조 const_reverse_iterator crIter 하려면 연산자를 -> 사용합니다.

요소에 대한 키 값에 액세스하려면 해당(*crIter).first되는 키를 사용합니다crIter->first. 요소에 대해 매핑된 데이텀의 값에 액세스하려면 해당(*crIter).second되는 를 사용합니다crIter->second.

예시

const_reverse_iterator를 선언하고 사용하는 방법에 대한 예제는 rend의 예제를 참조하세요.

hash_multimap::count

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

키가 매개 변수로 지정된 키와 일치하는 hash_multimap의 요소 수를 반환합니다.

size_type count(const Key& key) const;

매개 변수

key
hash_multimap에서 일치하는지 확인할 요소의 키입니다.

Return Value

hash_multimap에 정렬 키가 매개 변수 키와 일치하는 요소가 있는 경우 1이고, hash_multimap에 일치하는 키가 포함된 요소가 없는 경우 0입니다.

설명

멤버 함수는 다음 범위에 있는 요소 중에서

[lower_bound ( key ), upper_bound ( key ) )

키 값 키가 있는 경우

예시

다음 예제에서는 hash_multimap::count 멤버 함수의 사용을 보여 줍니다.

// hash_multimap_count.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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));

    // Elements do not need to have unique keys in hash_multimap,
    // so duplicates are allowed and counted
    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: 2.
The number of elements in hm1 with a sort key of 2 is: 2.
The number of elements in hm1 with a sort key of 3 is: 0.

hash_multimap::crbegin

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

역방향 hash_multimap에서 첫 번째 요소를 주소 지정하는 상수 반복기를 반환합니다.

const_reverse_iterator crbegin() const;

Return Value

역방향 hash_multimap에서 첫 번째 요소 또는 정방향 hash_multimap에서 마지막 요소의 주소를 지정하는 상수 역방향 양방향 반복기입니다.

설명

crbegin은 hash_multimap::begin이 hash_multimap에서 사용되는 것처럼 역방향 hash_multimap에서 사용됩니다.

반환 값이 crbegin이면 hash_multimap 개체를 수정할 수 없습니다.

crbegin은 hash_multimap을 역방향으로 반복할 때 사용할 수 있습니다.

예시

// hash_multimap_crbegin.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <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_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The first element of the reversed hash_multimap hm1 is 3.

hash_multimap::crend

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

역방향 hash_multimap에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 상수 반복기를 반환합니다.

const_reverse_iterator crend() const;

Return Value

역방향 hash_multimap에서 마지막 요소 다음의 위치(정방향 hash_multimap의 첫 번째 요소 앞의 위치) 주소를 지정하는 상수 역방향 양방향 반복기입니다.

설명

crend는 hash_multimap::end가 hash_multimap에서 사용되는 것처럼 역방향 hash_multimap에서 사용됩니다.

반환 값이 crend이면 hash_multimap 개체를 수정할 수 없습니다.

crend를 사용하여 역방향 반복기가 hash_multimap 끝에 도달했는지 여부를 테스트할 수 있습니다.

crend에서 반환한 값은 역참조되지 않아야 합니다.

예시

// hash_multimap_crend.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <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_multimap hm1 is "
        << hm1_crIter -> first << "." << endl;
}

The last element of the reversed hash_multimap hm1 is 3.

hash_multimap::d ifference_type

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

반복기가 가리키는 요소 사이의 범위에 있는 hash_multimap의 요소 수를 나타내는 데 사용할 수 있는 부호 있는 정수 형식입니다.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::difference_type difference_type;

설명

difference_type은 컨테이너의 반복기를 빼거나 더할 때 반환되는 형식입니다. difference_type은 일반적으로 first 및 last 반복기 사이의 [ first, last) 범위 내 요소 수를 나타내는 데 사용됩니다. 여기에는 first가 가리키는 요소에서 last가 가리키는 요소까지의 요소 범위가 포함됩니다(마지막 요소는 포함되지 않음).

입력 반복기 요구 사항을 충족하는 모든 반복기(set 등의 가역 컨테이너에서 지원하는 양방향 반복기 클래스 포함)에 대해 difference_type을 사용할 수는 있지만, 반복기 간의 빼기는 vector와 같은 임의 액세스 컨테이너가 제공하는 임의 액세스 반복기를 통해서만 지원됩니다.

예시

// hash_multimap_difference_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>
#include <algorithm>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<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 will insert, because map keys
    // do not need to be unique
    hm1.insert(Int_Pair(2, 30));

    hash_multimap<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_multimap
    hash_multimap<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_multimap 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_multimap hm1 is: 4.
The keys of the mapped elements are: 1 2 2 3.
The values of the mapped elements are: 10 20 30 20.

hash_multimap::emplace

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

생성된 요소를 hash_multimap에 삽입합니다.

template <class ValTy>
iterator emplace(ValTy&& val);

매개 변수

val
hash_multimap에 삽입할 요소를 이동 생성하는 데 사용되는 값입니다.

Return Value

emplace 멤버 함수는 새 요소가 삽입된 위치를 가리키는 반복기를 반환합니다.

설명

요소의 hash_multimap::value_type은 쌍으로, 요소의 값은 첫 번째 구성 요소가 키 값과 동일하고 두 번째 구성 요소가 요소의 데이터 값과 동일한 정렬된 쌍입니다.

예시

// hash_multimap_emplace.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(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_multimap::emplace_hint

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

배치 힌트를 사용하여 hash_multimap에 생성된 요소를 삽입합니다.

template <class ValTy>
iterator emplace_hint(
    const_iterator _Where,
    ValTy&& val);

매개 변수

val
hash_multimap이 해당 요소(또는 더 일반적으로는 키가 동등하게 정렬된 요소)를 이미 포함하고 있지 않을 경우 hash_multimap에 삽입되는 요소를 이동 생성하는 데 사용되는 값입니다.

_Where
올바른 삽입 지점 검색을 시작할 위치와 관련된 힌트입니다.

Return Value

hash_multimap::emplace 멤버 함수는 새 요소를 hash_multimap에 삽입한 위치를 가리키는 반복기를 반환합니다.

설명

삽입 지점이 _Where 바로 뒤에 있는 경우 로그 시간 대신 분할 상환 상수 시간에 삽입이 발생할 수 있습니다.

예시

// hash_multimap_emplace_hint.cpp
// compile with: /EHsc
#include<hash_multimap>
#include<iostream>
#include <string>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, string> hm1;
    typedef pair<int, string> is1(1, "a");

    hm1.emplace(hm1.begin(), 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_multimap::empty

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap이 비어 있는지 테스트합니다.

bool empty() const;

Return Value

true hash_multimap 비어 있으면 false hash_multimap 없음이면

설명

예시

// hash_multimap_empty.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2;

   typedef pair <int, int> Int_Pair;
   hm1.insert ( Int_Pair ( 1, 1 ) );

   if ( hm1.empty( ) )
      cout << "The hash_multimap hm1 is empty." << endl;
   else
      cout << "The hash_multimap hm1 is not empty." << endl;

   if ( hm2.empty( ) )
      cout << "The hash_multimap hm2 is empty." << endl;
   else
      cout << "The hash_multimap hm2 is not empty." << endl;
}

The hash_multimap hm1 is not empty.
The hash_multimap hm2 is empty.

hash_multimap::end

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 반복기를 반환합니다.

const_iterator end() const;

iterator end();

Return Value

hash_multimap에서 마지막 요소 다음에 나오는 위치의 주소를 지정하는 양방향 반복기입니다. hash_multimap이 비어 있으면 hash_multimap::end == hash_multimap::begin입니다.

설명

end는 반복기가 hash_multimap의 끝에 도달했는지 여부를 테스트하는 데 사용됩니다.

end에서 반환한 값은 역참조되지 않아야 합니다.

예시

// hash_multimap_end.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <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_multimap::equal_range

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

지정된 키보다 더 큰 키를 가진 hash_multimap의 첫 번째 요소와 지정된 키보다 더 크거나 같은 키를 가진 hash_multimap의 첫 번째 요소에 반복기의 쌍을 각각 반환합니다.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

매개 변수

key
검색 중인 hash_multimap에서 요소의 정렬 키와 비교할 인수 키입니다.

Return Value

반복기 쌍. 여기서 첫 번째 반복기는 키의 lower_bound이고 두 번째 반복기는 키의 upper_bound입니다.

구성원 함수가 반환하는 pr 쌍의 첫 번째 반복기에 액세스하려면 pr. 먼저 하한 반복기를 역참조하려면 *( pr. 먼저). 구성원 함수가 반환하는 pr 쌍의 두 번째 반복기에 액세스하려면 pr. 두 번째 및 상한 반복기를 역참조하려면 *( pr. 두 번째).

설명

예시

// hash_multimap_equal_range.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_multimap <int, int> IntMMap;
   IntMMap hm1;
   hash_multimap <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 <IntMMap::const_iterator, IntMMap::const_iterator> p1, p2;
   p1 = hm1.equal_range( 2 );

   cout << "The lower bound of the element with a key of 2\n"
        << "in the hash_multimap hm1 is: "
        << p1.first -> second << "." << endl;

   cout << "The upper bound of the element with a key of 2\n"
        << "in the hash_multimap 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_multimap hm1 doesn't have an element "
           << "with a key less than 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key >= 40 is: "
           << p1.first -> first << "." << endl;
}

The lower bound of the element with a key of 2
in the hash_multimap hm1 is: 20.
The upper bound of the element with a key of 2
in the hash_multimap 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_multimap hm1 doesn't have an element with a key less than 4.

hash_multimap::erase

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

지정된 위치에서 hash_multimap의 요소 또는 요소의 범위를 제거하거나 지정된 키와 일치하는 요소를 제거합니다.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

매개 변수

_Where
hash_multimap에서 제거할 요소의 위치입니다.

first
hash_multimap에서 제거된 첫 번째 요소의 위치입니다.

last
hash_multimap에서 제거된 마지막 요소 바로 뒤의 위치입니다.

key
hash_multimap에서 제거할 요소의 키입니다.

Return Value

처음 두 멤버 함수의 경우 제거된 요소 뒤에 남은 첫 번째 요소를 지정하는 양방향 반복기이거나 이러한 요소가 없을 경우 hash_multimap의 끝에 대한 포인터입니다.

세 번째 멤버 함수의 경우 hash_multimap에서 제거된 요소의 수를 반환합니다.

설명

멤버 함수는 예외를 throw하지 않습니다.

예시

다음 예제에서는 hash_multimap::erase 멤버 함수의 사용을 보여 줍니다.

// hash_multimap_erase.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2, hm3;
    hash_multimap<int, int> :: iterator pIter, Iter1, Iter2;
    int i;
    hash_multimap<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_multimap 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_multimap 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
    hm3.insert(Int_Pair (2, 5));
    n = hm3.erase(2);

    cout << "After the element with a key of 2 is deleted,\n"
         << "the hash_multimap 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 of the"
         << endl;
    cout  << "2nd element is deleted, "
          << "the hash_multimap hm3 is:";
    for (pIter = hm3.begin(); pIter != hm3.end(); pIter++)
        cout << " " << pIter -> second;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_multimap hm1 is: 1 3 4.
After the middle two elements are deleted, the hash_multimap hm2 is: 1 16.
After the element with a key of 2 is deleted,
the hash_multimap hm3 is: 0 2 3.
The number of elements removed from hm3 is: 2.
After another element with a key equal to that of the
2nd element is deleted, the hash_multimap hm3 is: 0 3.

hash_multimap::find

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

지정된 키와 같은 키를 가진 hash_multimap 내 요소의 첫 번째 위치를 가리키는 반복기를 반환합니다.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

매개 변수

key
검색 중인 hash_multimap에서 요소의 정렬 키와 일치 여부를 확인할 키입니다.

Return Value

지정된 키를 포함하는 요소의 첫 번째 위치 또는 해당 키와 일치하는 항목이 없는 경우 hash_multimap의 마지막 요소 다음 위치에 대한 주소를 지정하는 반복기입니다.

설명

멤버 함수는 비교 가능성이 낮은 관계를 기반으로 정렬을 유도하는 이진 조건자의 인수 키에 대한 정렬 키가 equivalent 있는 hash_multimap 요소를 해결하는 반복기를 반환합니다.

find의 반환 값이 const_iterator에 할당된 경우 hash_multimap 개체는 수정할 수 없습니다. 반환 값 find 이 할당 iterator된 경우 hash_multimap 개체를 수정할 수 있습니다.

예시

// hash_multimap_find.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_map>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1;
    hash_multimap<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, 20));
    hm1.insert(Int_Pair(3, 30));

    hm1_RcIter = hm1.find(2);
    cout << "The element of hash_multimap hm1 with a key of 2 is: "
          << hm1_RcIter -> second << "." << endl;

    hm1_RcIter = hm1.find(3);
    cout << "The first element of hash_multimap hm1 with a key of 3 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_multimap hm1 doesn't have an element "
             << "with a key of 4." << endl;
    else
        cout << "The element of hash_multimap hm1 with a key of 4 is: "
             << hm1_RcIter -> second << "." << endl;

    // The element at a specific location in the hash_multimap 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 first element of hm1 with a key matching"
         << endl << "that of the last element is: "
         << hm1_RcIter -> second << "." << endl;

    // Note that the first element with a key equal to
    // the key of the last element is not the last element
    if (hm1_RcIter == --hm1.end())
        cout << "This is the last element of hash_multimap hm1."
             << endl;
    else
        cout << "This is not the last element of hash_multimap hm1."
             << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::get_allocator

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap을 생성하는 데 사용되는 할당자 개체의 복사본을 반환합니다.

Allocator get_allocator() const;

Return Value

hash_multimap에서 사용되는 할당자입니다.

설명

hash_multimap 클래스의 할당자는 클래스가 스토리지를 관리하는 방법을 지정합니다. C++ 표준 라이브러리 컨테이너 클래스와 함께 제공되는 기본 할당자를 사용하면 대부분의 프로그래밍 요구 사항을 충족할 수 있습니다. 할당자 클래스를 직접 작성하고 사용하는 방법에 대해서는 고급 C++ 항목에서 다룹니다.

예시

// hash_multimap_get_allocator.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int>::allocator_type hm1_Alloc;
   hash_multimap <int, int>::allocator_type hm2_Alloc;
   hash_multimap <int, double>::allocator_type hm3_Alloc;
   hash_multimap <int, int>::allocator_type hm4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> hm2;
   hash_multimap <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_multimap hm4
   // with the allocator of hash_multimap hm1.
   hash_multimap <int, int> hm4( less<int>( ), hm1_Alloc );

   hm4_Alloc = hm4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated by the other
   if( hm1_Alloc == hm4_Alloc )
   {
      cout << "The allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "The allocators are not interchangeable."
           << endl;
   }
}

hash_multimap::hash_multimap

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

비어 있거나 일부 다른 hash_multimap의 전체 또는 부분에 대한 복사본인 hash_multimap을 생성합니다.

hash_multimap();

explicit hash_multimap(
    const Compare& Comp);

hash_multimap(
    const Compare& Comp,
    const Allocator& Al);

hash_multimap(
    const hash_multimap& Right);

hash_multimap(
    hash_multimap&& Right);

hash_multimap(
    initializer_list<Type> IList);

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp);

hash_multimap(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

template <class InputIterator>
hash_multimap(
    InputIterator First,
    InputIterator Last,
    const Compare& Comp,
    const Allocator& Al);

매개 변수

Al
이 hash_multimap 개체에 사용할 스토리지 할당자 클래스로, 기본값은 Allocator입니다.

광고
map의 요소 순서를 지정하는 데 사용되는 const Traits 형식의 비교 함수로, 기본값은 Traits입니다.

Right
생성된 set을 복사할 map입니다.

첫째
복사할 요소의 범위에서 첫 번째 요소의 위치입니다.

마지막
복사할 요소의 범위를 벗어나는 첫 번째 요소의 위치입니다.

IList
복사할 원본 initializer_list입니다.

설명

모든 생성자는 hash_multimap의 메모리 스토리지를 관리하며 나중에 get_allocator를 호출하여 반환할 수 있는 할당자 개체 형식을 저장합니다. allocator 매개 변수는 대체 할당자를 대체하는 데 사용되는 전처리 매크로 및 클래스 선언에서 생략되는 경우가 많습니다.

모든 생성자는 해당 hash_multimap을 초기화합니다.

모든 생성자는 hash_multimap의 키 간 순서를 설정하는 데 사용되며 나중에 key_comp를 호출하여 반환할 수 있는 Traits 형식의 함수 개체를 저장합니다.

처음 세 개의 생성자는 빈 초기 hash_multimap 지정합니다. 두 번째는 요소의 순서를 설정하는 데 사용할 비교 함수(Comp)의 형식을 지정하고 세 번째는 사용할 할당자 형식(_Al)을 명시적으로 지정합니다. explicit 키워드를 사용하는 경우 특정 종류의 자동 형식 변환이 수행되지 않습니다.

네 번째 생성자는 Right hash_multimap의 복사본을 지정합니다.

다음 세 생성자는 map의 범위 First, Last)를 복사하여, Traits 클래스 및 할당자의 비교 함수 형식을 지정할 때 명시도가 향상됩니다.

여덟 번째 생성자는 hash_multimap Right를 이동합니다.

마지막 3개 생성자는 initializer_list를 사용합니다.

hash_multimap::insert

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에 요소 또는 요소의 범위를 삽입합니다.

iterator insert(
    const value_type& Val);

iterator insert(
    const_iterator Where,
    const value_type& Val);void insert(
    initializer_list<value_type> IList);

template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

template <class ValTy>
iterator insert(
    ValTy&& Val);

template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

매개 변수

Val
해당 요소를 이미 포함하고 있지 않을 경우 또는 보다 일반적으로 키가 동등하게 정렬된 요소를 이미 포함하고 있지 않을 경우 hash_multimap에 삽입되는 요소의 값입니다.

Where
올바른 삽입 지점 검색을 시작할 위치에 대한 힌트입니다.

첫째
맵에서 복사할 첫 번째 요소의 위치입니다.

마지막
맵에서 복사할 마지막 요소 바로 다음 위치입니다.

Return Value

처음 두 insert 멤버 함수는 새 요소가 삽입된 위치를 가리키는 반복기를 반환합니다.

세 번째 멤버 함수는 삽입할 요소에 initializer_list를 사용합니다.

네 번째 멤버 함수는 지정된 집합의 [First, Last) 범위에서 반복기가 주소를 지정하는 각 요소에 해당하는 맵에 요소 값의 시퀀스를 삽입합니다.

마지막 두 insert 멤버 함수는 삽입된 값을 이동-생성한다는 점을 제외하고 처음 두 함수와 똑같이 동작합니다.

설명

요소의 value_type 은 쌍으로, 요소의 값은 첫 번째 구성 요소가 키 값과 동일하고 두 번째 구성 요소가 요소의 데이터 값과 동일한 정렬된 쌍입니다.

삽입 지점이 Where 바로 뒤에 있는 경우 로그 시간 대신 힌트 버전의 insert분할 상환 상수 시간에 삽입이 발생할 수 있습니다.

hash_multimap::iterator

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에 있는 모든 요소를 읽거나 수정할 수 있는 양방향 반복기를 제공하는 형식입니다.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::iterator iterator;

설명

hash_multimap 정의된 개체는 iterator const Key 형식<pair인 value_type 개체를 가리키며,> 첫 번째 멤버는 요소의 키이고 두 번째 멤버는 요소가 보유한 매핑된 데이텀입니다.

hash_multimap 요소를 가리키는 반복 Iter 기를 역참조하려면 연산자를 -> 사용합니다.

요소에 대한 키 값에 액세스하려면 해당(*Iter).first되는 키를 사용합니다Iter->first. 요소에 대해 매핑된 데이텀의 값에 액세스하려면 해당(*Iter).first되는 를 사용합니다Iter->second.

형식 iterator 을 사용하여 요소의 값을 수정할 수 있습니다.

예시

iterator를 선언하고 사용하는 방법에 대한 예제는 begin의 예제를 참조하세요.

hash_multimap::key_comp

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에서 키를 정렬하기 위해 사용하는 비교 개체의 복사본을 검색합니다.

key_compare key_comp() const;

Return Value

hash_multimap이 요소의 순서를 지정하는 데 사용하는 함수 개체를 반환합니다.

설명

저장된 개체는 멤버 함수

bool operator( const Key& left, const Key& right );

앞에 오는 경우 left 를 반환하고 정렬 순서와 같지 않은 경우를 반환 true 하는 right 입니다.

예시

// hash_multimap_key_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::key_compare kc1 = hm1.key_comp( ) ;
   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.\n"
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false,\n"
           << "where kc1 is the function object of hm1.\n"
           << endl;
   }

   hash_multimap <int, int, hash_compare<int, greater<int>>> hm2;
   hash_multimap <int, int, hash_compare<int, greater<int>>
      >::key_compare kc2 = hm2.key_comp( );
   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."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false,\n"
           << "where kc2 is the function object of hm2."
           << endl;
   }
}

hash_multimap::key_compare

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap의 두 요소 간 상대적 순서를 결정하는 두 정렬 키를 비교할 수 있는 함수 개체를 제공하는 형식입니다.

typedef Traits key_compare;

설명

key_compare 는 템플릿 매개 변수 특성의 동의어입니다.

특성에 대한 자세한 내용은 hash_multimap 클래스 항목을 참조 하세요.

예시

key_compare를 선언하고 사용하는 방법에 대한 예제는 key_comp의 예제를 참조하세요.

hash_multimap::key_type

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap의 각 요소를 구성하는 정렬 키 개체를 설명하는 형식입니다.

typedef Key key_type;

설명

key_type 는 템플릿 매개 변수 키의 동의어입니다.

키에 대한 자세한 내용은 hash_multimap 클래스 항목의 설명 섹션을 참조하세요.

예시

key_compare을 선언하고 사용하는 방법에 대한 예제는 value_type의 예제를 참조하세요.

hash_multimap::lower_bound

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에서 지정된 키보다 크거나 같은 키를 가진 첫 번째 요소에 반복기를 반환합니다.

iterator lower_bound(const Key& key);

const_iterator lower_bound(const Key& key) const;

매개 변수

key
검색 중인 hash_multimap에서 요소의 정렬 키와 비교할 인수 키입니다.

Return Value

인수 키보다 크거나 같은 키가 들어 있는 hash_multimap 내 요소의 위치 주소를 지정하거나, 키와 일치하는 항목이 없는 경우 hash_multimap에서 마지막 요소 다음 위치의 주소를 지정하는 iterator 또는 const_iterator입니다.

lower_bound의 반환 값이 const_iterator에 할당된 경우 hash_multimap 개체는 수정할 수 없습니다. 반환 값 lower_bound 이 할당 iterator된 경우 hash_multimap 개체를 수정할 수 있습니다.

설명

예시

// hash_multimap_lower_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <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, 20 ) );
   hm1.insert ( Int_Pair ( 3, 30 ) );

   hm1_RcIter = hm1.lower_bound( 2 );
   cout << "The element of hash_multimap hm1 with a key of 2 is: "
        << hm1_RcIter -> second << "." << endl;

   hm1_RcIter = hm1.lower_bound( 3 );
   cout << "The first element of hash_multimap hm1 with a key of 3 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_multimap hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_multimap 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 first element of hm1 with a key matching"
        << endl << "that of the last element is: "
        << hm1_RcIter -> second << "." << endl;

   // Note that the first element with a key equal to
   // the key of the last element is not the last element
   if ( hm1_RcIter == --hm1.end( ) )
      cout << "This is the last element of hash_multimap hm1."
           << endl;
   else
      cout << "This is not the last element of hash_multimap hm1."
           << endl;
}

The element of hash_multimap hm1 with a key of 2 is: 20.
The first element of hash_multimap hm1 with a key of 3 is: 20.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key matching
that of the last element is: 20.
This is not the last element of hash_multimap hm1.

hash_multimap::mapped_type

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에 저장된 데이터 형식을 나타내는 형식입니다.

typedef Type mapped_type;

설명

mapped_type은 템플릿 매개 변수 Type의 동의어입니다.

형식에 대한 자세한 내용은 hash_multimap 클래스 항목을 참조하세요.

예시

key_type을 선언하고 사용하는 방법에 대한 예제는 value_type의 예제를 참조하세요.

hash_multimap::max_size

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap의 최대 길이를 반환합니다.

size_type max_size() const;

Return Value

hash_multimap의 최대 허용 길이입니다.

설명

예시

// hash_multimap_max_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <int, int> :: size_type i;

   i = hm1.max_size( );
   cout << "The maximum possible length "
        << "of the hash_multimap is " << i << "." << endl;
}

hash_multimap::operator=

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap의 요소를 다른 hash_multimap의 복사본으로 바꿉니다.

hash_multimap& operator=(const hash_multimap& right);

hash_multimap& operator=(hash_multimap&& right);

매개 변수

right
hash_multimap에 복사되는 hash_multimap입니다.

설명

기존 요소를 hash_multimapoperator= 지워서 오른쪽hash_multimap의 내용을 복사하거나 이동합니다.

예시

// hash_multimap_operator_as.cpp
// compile with: /EHsc
#include <hash_multimap>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap<int, int> v1, v2, v3;
   hash_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;
}

hash_multimap::p오인터

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에서 요소에 대한 포인터를 제공하는 형식입니다.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::pointer pointer;

설명

형식 pointer 을 사용하여 요소의 값을 수정할 수 있습니다.

대부분의 경우 iterator를 사용하여 hash_multimap 개체의 요소에 액세스해야 합니다.

hash_multimap::rbegin

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

역방향 hash_multimap에서 첫 번째 요소를 주소 지정하는 반복기를 반환합니다.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Return Value

역방향 hash_multimap에서 첫 번째 요소 또는 정방향 hash_multimap에서 마지막 요소의 주소를 지정하는 역방향 양방향 반복기입니다.

설명

rbegin은 begin이 hash_multimap에서 사용되는 것처럼 역방향 hash_multimap에서 사용됩니다.

rbegin의 반환 값이 const_reverse_iterator에 할당된 경우 hash_multimap 개체는 수정할 수 없습니다. rbegin의 반환 값이 reverse_iterator에 할당된 경우에는 hash_multimap 개체를 수정할 수 있습니다.

rbegin은 hash_multimap을 역방향으로 반복할 때 사용할 수 있습니다.

예시

// hash_multimap_rbegin.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <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_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap 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_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_multimap element can be erased by dereferencing its key
   hm1_rIter = hm1.rbegin( );
   hm1.erase ( hm1_rIter -> first );

   hm1_rIter = hm1.rbegin( );
   cout << "After the erasure, the first element\n"
        << "in the reversed hash_multimap is "
        << hm1_rIter -> first << "." << endl;
}

The first element of the reversed hash_multimap hm1 is 3.
The hash_multimap is: 1 2 3 .
The reversed hash_multimap is: 3 2 1 .
After the erasure, the first element
in the reversed hash_multimap is 2.

hash_multimap::reference

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에 저장된 요소에 대한 참조를 제공하는 형식입니다.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::reference reference;

설명

예시

// hash_multimap_reference.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <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_multimap 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_multimap 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_multimap is 1.
The data value of first element in the hash_multimap is 10.
The modified data value of first element is 15.

hash_multimap::rend

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

역방향 hash_multimap에서 마지막 요소 다음에 나오는 위치의 주소를 지정하는 반복기를 반환합니다.

const_reverse_iterator rend() const;

reverse_iterator rend();

Return Value

역방향 hash_multimap에서 마지막 요소 다음의 위치(정방향 hash_multimap의 첫 번째 요소 앞의 위치) 주소를 지정하는 역방향 양방향 반복기입니다.

설명

rend은 end가 hash_multimap에서 사용되는 것처럼 역방향 hash_multimap에서 사용됩니다.

rend의 반환 값이 const_reverse_iterator에 할당되는 경우에는 hash_multimap 개체를 수정할 수 없습니다. rend의 반환 값이 reverse_iterator에 할당되는 경우에는 hash_multimap 개체를 수정할 수 있습니다.

rend를 사용하여 역방향 반복기가 hash_multimap 끝에 도달했는지 여부를 테스트할 수 있습니다.

rend에서 반환한 값은 역참조되지 않아야 합니다.

예시

// hash_multimap_rend.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;

   hash_multimap <int, int> :: iterator hm1_Iter;
   hash_multimap <int, int> :: reverse_iterator hm1_rIter;
   hash_multimap <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_multimap hm1 is "
        << hm1_rIter -> first << "." << endl;

   // begin can be used to start an iteration
   // through a hash_multimap in a forward order
   cout << "The hash_multimap 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_multimap in a reverse order
   cout << "The reversed hash_multimap is: ";
   for ( hm1_rIter = hm1.rbegin( ) ; hm1_rIter != hm1.rend( ); hm1_rIter++)
      cout << hm1_rIter -> first << " ";
      cout << "." << endl;

   // A hash_multimap element can be erased by dereferencing 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_multimap is "
        << hm1_rIter -> first << "." << endl;
}

The last element of the reversed hash_multimap hm1 is 1.
The hash_multimap is: 1 2 3 .
The reversed hash_multimap is: 3 2 1 .
After the erasure, the last element in the reversed hash_multimap is 2.

hash_multimap::reverse_iterator

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

역방향 hash_multimap의 요소를 읽거나 수정할 수 있는 양방향 반복기를 제공하는 형식입니다.

typedef list<typename Traits::value_type, typename Traits::allocator_type>::reverse_iterator reverse_iterator;

설명

reverse_iterator 형식은 hash_multimap을 역방향으로 반복하는 데 사용됩니다.

hash_multimap 정의된 것은 reverse_iterator const Key, Type> 형식<pair인 value_type 개체를 가리킵니다. 키의 값은 첫 번째 멤버 쌍을 통해 제공되며 매핑된 요소의 값은 쌍의 두 번째 멤버를 통해 제공됩니다.

예시

reverse_iterator를 선언하고 사용하는 방법에 대한 예제는 rbegin의 예제를 참조하세요.

hash_multimap::size

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에 있는 요소 수를 반환합니다.

size_type size() const;

Return Value

hash_multimap의 현재 길이입니다.

설명

예시

다음 예제에서는 hash_multimap::size 멤버 함수의 사용을 보여 줍니다.

// hash_multimap_size.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_multimap<int, int> hm1, hm2;
    hash_multimap<int, int>::size_type i;
    typedef pair<int, int> Int_Pair;

    hm1.insert(Int_Pair(1, 1));
    i = hm1.size();
    cout << "The hash_multimap length is " << i << "." << endl;

    hm1.insert(Int_Pair(2, 4));
    i = hm1.size();
    cout << "The hash_multimap length is now " << i << "." << endl;
}

The hash_multimap length is 1.
The hash_multimap length is now 2.

hash_multimap::size_type

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에서 요소 수를 계산하는 부호 없는 정수 형식입니다.

typedef list<typename _Traits::value_type, typename _Traits::allocator_type>::size_type size_type;

설명

예시

size_type을 선언하고 사용하는 방법에 대한 예제는 size의 예제를 참조하세요.

hash_multimap::swap

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

두 hash_multimap의 요소를 교환합니다.

void swap(hash_multimap& right);

매개 변수

right
교환할 요소를 제공하는 hash_multimap 또는 hash_multimap과 요소를 교환할 hash_multimap입니다.

설명

멤버 함수는 해당 요소를 교환할 두 hash_multimap의 요소를 지정하는 참조, 포인터 또는 반복기를 무효화하지 않습니다.

예시

// hash_multimap_swap.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1, hm2, hm3;
   hash_multimap <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_multimap 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
   hm1.swap( hm2 );

   cout << "After swapping with hm2, hash_multimap 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_multimap hm1 is:";
   for ( hm1_Iter = hm1.begin( ); hm1_Iter != hm1.end( ); hm1_Iter++ )
      cout << " " << hm1_Iter -> second;
   cout   << "." << endl;
}

The original hash_multimap hm1 is: 10 20 30.
After swapping with hm2, hash_multimap hm1 is: 100 200.
After swapping with hm3, hash_multimap hm1 is: 300.

hash_multimap::upper_bound

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에서 지정된 키보다 큰 키를 가진 첫 번째 요소에 반복기를 반환합니다.

iterator upper_bound(const Key& key);

const_iterator upper_bound(const Key& key) const;

매개 변수

key
검색 중인 hash_multimap에서 요소의 정렬 키와 비교할 인수 키입니다.

Return Value

인수 키보다 더 큰 키가 들어 있는 hash_multimap 내 요소의 위치 주소를 지정하거나, 키와 일치하는 항목이 없는 경우 hash_multimap에서 마지막 요소 다음 위치의 주소를 지정하는 iterator 또는 const_iterator입니다.

upper_bound의 반환 값이 const_iterator에 할당된 경우 hash_multimap 개체는 수정할 수 없습니다. 반환 값 upper_bound 이 할당 iterator된 경우 hash_multimap 개체를 수정할 수 있습니다.

설명

예시

// hash_multimap_upper_bound.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_multimap <int, int> hm1;
   hash_multimap <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.insert ( Int_Pair ( 3, 40 ) );

   hm1_RcIter = hm1.upper_bound( 1 );
   cout << "The 1st element of hash_multimap hm1 with "
        << "a key greater than 1 is: "
        << hm1_RcIter -> second << "." << endl;

   hm1_RcIter = hm1.upper_bound( 2 );
   cout << "The first element of hash_multimap hm1\n"
        << "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.lower_bound( 4 );

   if ( hm1_RcIter == hm1.end( ) )
      cout << "The hash_multimap hm1 doesn't have an element "
           << "with a key of 4." << endl;
   else
      cout << "The element of hash_multimap hm1 with a key of 4 is: "
           << hm1_RcIter -> second << "." << endl;

   // The element at a specific location in the hash_multimap can be
   // found using a dereferenced iterator addressing the location
   hm1_AcIter = hm1.begin( );
   hm1_RcIter = hm1.upper_bound( hm1_AcIter -> first );
   cout << "The first element of hm1 with a key greater than"
        << endl << "that of the initial element of hm1 is: "
        << hm1_RcIter -> second << "." << endl;
}

The 1st element of hash_multimap hm1 with a key greater than 1 is: 20.
The first element of hash_multimap hm1
with a key  greater than 2 is: 30.
The hash_multimap hm1 doesn't have an element with a key of 4.
The first element of hm1 with a key greater than
that of the initial element of hm1 is: 20.

hash_multimap::value_comp

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

멤버 함수는 키 값을 비교하여 hash_multimap의 요소 순서를 결정하는 함수 개체를 반환합니다.

value_compare value_comp() const;

Return Value

hash_multimap이 요소의 순서를 지정하는 데 사용하는 비교 함수 개체를 반환합니다.

설명

hash_multimap m의 경우 e1(k1, d1) 및 e2(k2, d2) 요소가 value_type 형식의 개체인 경우 k1과 k2는 key_type 형식의 키이고 d1과 d2는 mapped_type 형식의 데이터인 경우 m.value_comp()(e1, e2) 와 동일합니다.m.key_comp()(k1, k2) 저장된 개체는 멤버 함수

bool operator( value_type& left, value_type& right);

의 키 값이 앞에 있고 정렬 순서의 left 키 값 right 과 같지 않은 경우를 반환 true 합니다.

예시

// hash_multimap_value_comp.cpp
// compile with: /EHsc
#include <hash_map>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;

   hash_multimap <int, int, hash_compare<int, less<int>>> hm1;
   hash_multimap <int, int, hash_compare<int, less<int>>
      >::value_compare vc1 = hm1.value_comp( );
   hash_multimap <int,int>::iterator Iter1, Iter2;

   Iter1= hm1.insert ( hash_multimap <int, int> :: value_type ( 1, 10 ) );
   Iter2= hm1.insert ( hash_multimap <int, int> :: value_type ( 2, 5 ) );

   if( vc1( *Iter1, *Iter2 ) == 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( *Iter2, *Iter1 ) == 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_multimap::value_type

참고 항목

이 API는 더 이상 사용되지 않습니다. 다른 방법은 unordered_multimap Class입니다.

hash_multimap에 저장된 개체의 형식을 나타내는 형식입니다.

typedef pair<const Key, Type> value_type;

설명

value_type<는 연결 컨테이너의 키가 비연속 반복기 또는 참조를 사용하여 변경되지 않을 수 있으므로 쌍 key_type<> > mapped_type 쌍 key_type mapped_type 선언됩니다.

예시

// hash_multimap_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_multimap <int, int> hm1;
   hash_multimap <int, int> :: key_type key1;
   hash_multimap <int, int> :: mapped_type mapped1;
   hash_multimap <int, int> :: value_type value1;
   hash_multimap <int, int> :: iterator pIter;

   // value_type can be used to pass the correct type
   // explicitly to avoid implicit type conversion
   hm1.insert ( hash_multimap <int, int> :: value_type ( 1, 10 ) );

   // Compare another way to insert objects into a hash_multimap
   hm1.insert ( cInt2Int ( 2, 20 ) );

   // Initializing key1 and mapped1
   key1 = ( hm1.begin( ) -> first );
   mapped1 = ( hm1.begin( ) -> second );

   cout << "The key of first element in the hash_multimap is "
        << key1 << "." << endl;

   cout << "The data value of first element in the hash_multimap 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_multimap is 1.
The data value of first element in the hash_multimap is 10.
The keys of the mapped elements are: 1 2.
The values of the mapped elements are: 10 20.

참고 항목

C++ 표준 라이브러리의 스레드 보안
C++ 표준 라이브러리 참조

다음을 통해 공유

hash_multimap 클래스

구문

매개 변수

설명

생성자

Typedef

멤버 함수

연산자

요구 사항

hash_multimap::allocator_type

설명

예시

hash_multimap::begin

Return Value

설명

예시

hash_multimap::cbegin

Return Value

예시

hash_multimap::cend

Return Value

설명

예시

hash_multimap::clear

설명

예시

hash_multimap::const_iterator

설명

예시

hash_multimap::const_pointer

설명

hash_multimap::const_reference

설명

예시

hash_multimap::const_reverse_iterator

설명

예시

hash_multimap::count

매개 변수

Return Value

설명

예시

hash_multimap::crbegin

Return Value

설명

예시

hash_multimap::crend

Return Value

설명

예시

hash_multimap::d ifference_type

설명

예시

hash_multimap::emplace

매개 변수

Return Value

설명

예시

hash_multimap::emplace_hint

매개 변수

Return Value

설명

예시

hash_multimap::empty

Return Value

설명

예시

hash_multimap::end

Return Value

설명

예시

hash_multimap::equal_range

매개 변수

Return Value

설명

예시

hash_multimap::erase

매개 변수

Return Value