Класс hash_set

Контейнерный класс hash_set является расширением стандартной библиотеки C++ и используется для хранения и быстрого извлечения данных из коллекции, в которой значения элементов уникальны и используются как значения ключа.

Синтаксис

template <class Key,
    class Traits=hash_compare<Key, less<Key>>,
    class Allocator=allocator<Key>>
class hash_set

Параметры

Ключ
Тип данных элемента, который будет сохранен в hash_set.

Признаки
Тип, включающий два объекта функции, один из классов сравнения классов, который является двоичным предикатом, способным сравнить два значения элементов в виде ключей сортировки, чтобы определить их относительный порядок и хэш-функцию, которая является унарным сопоставлением ключевых значений ключей элементов с неподписанными целыми числами типа size_t. Этот аргумент является необязательным, и в качестве значения по умолчанию используется hash_compare<Key, less<Key> >.

Распределителя
Тип, представляющий сохраненный объект распределителя, который инкапсулирует сведения о выделении и освобождении памяти для hash_set. Этот аргумент является необязательным, и в качестве значения по умолчанию используется allocator<Key>.

Замечания

hash_set это:

• Ассоциативный контейнер, который является контейнером переменного размера, поддерживающим эффективное получение значений элементов на основе значения соответствующего ключа. Кроме того, это простой ассоциативный контейнер, поскольку его значения элементов являются значениями его ключей.

• Является реверсивным, поскольку предоставляет двунаправленный итератор для получения доступа к его элементам.

• Хэшируется, поскольку его элементы группируются в сегменты на основе значения хэш-функции, применяемой к значениям ключей элементов.

• Является уникальным, поскольку каждый его элемент должен обладать уникальным ключом. Поскольку hash_set также является простым ассоциативным контейнером, его элементы также уникальны.

• Шаблон класса, так как функциональность, которая предоставляется, является универсальной и поэтому независимо от конкретного типа данных, содержащихся в виде элементов или ключей. Типы данных, используемые для элементов и ключей, вместо этого определяются как параметры в шаблоне класса вместе с функцией и распределителем сравнения.

Главным преимуществом хэширования по сравнению с сортировкой является большая эффективность: успешное хэширование выполняет вставки, удаления и поиск с постоянным средним временем, в то время как время для методик сортировки пропорционально логарифму числа элементов в контейнере. Значение элемента в наборе нельзя изменить напрямую. Вместо этого старые значения необходимо удалить и вставить элементы с новыми значениями.

Выбор типа контейнера должен в общем случае производиться на основе типа поиска и вставки, который требуется приложению. Хэшированные ассоциативные контейнеры оптимизированы для операций поиска, вставки и удаления. Функции-члены, которые явно поддерживают эти операции, эффективны при использовании совместно с правильно разработанной хэш-функцией, в результате чего они имеют постоянное среднее время выполнения и не зависят от числа элементов в контейнере. Правильно разработанная хэш-функция обеспечивает равномерное распределение хэшированных значений и сводит к минимуму количество конфликтов, когда разные значения ключей сопоставляются с одним хэшированным значением. В худшем случае, когда применяется наиболее неоптимальная хэш-функция, количество операций пропорционально количеству элементов в последовательности (линейное время).

hash_set рекомендуется использовать в качестве ассоциативного контейнера, если условия, ассоциирующие значения с ключами, удовлетворяются приложением. Элементы hash_set являются уникальными и используются в качестве своих собственных ключей сортировки. Модель для этого типа структуры — упорядоченный список, например, ключевых слов, в котором слова не должны повторяться. Если допускается многократное использование слов, то подходящей структурой контейнера будет hash_multiset. Если значения вносятся в список уникальных ключевых слов, hash_map является подходящей структурой для размещения этих данных. Если же ключи не являются уникальными, предпочтительным контейнером является hash_multimap.

Hash_set упорядочивает последовательность, которая управляется путем вызова хранимого хэш-объекта Traits типа value_compare. Доступ к этому хранимому объекту можно получить через вызов функции-члена key_comp. Такой объект функции должен вести себя так же, как объект класса hash_compare<Key, меньше<ключа>>. В частности, для всех значений key типа Key метод call Trait(key) дает распределение значений типа size_t.

В целом, упорядочиваемые элементы должны лишь подлежать сравнению "меньше чем" для установления такого порядка, чтобы, имея любые два элемента, можно было определить, что они равны (ни один не меньше другого) или что один меньше другого. Это приводит к упорядочению неравнозначных элементов. С более технической точки зрения, функция сравнения является бинарным предикатом, который вызывает строгого слабое упорядочение в стандартном математически смысле. Бинарный предикат f( x, y) является объектом-функцией с двумя аргументами — x и y и возвращаемым значением true или false. Упорядочивание в hash_set — это строгое слабое упорядочивание, если двоичный предикат является нерефлексивным, антисимметричным и транзитивным, и если эквивалентность транзитивна, где два объекта x и y определены как эквивалентные, если и f( x, y), и f( y, x) имеют значение false. Если более строгое условие равенства между ключами заменяет условие эквивалентности, порядок становится общим (т.е. все элементы упорядочиваются относительно друг друга), и сопоставленные ключи будут неотличимы друг от друга.

Фактический порядок элементов в управляемой последовательности зависит от хэш-функции, функции упорядочения и текущего размера хэш-таблицы, хранимой в объекте контейнера. Текущий размер хэш-таблицы определить нельзя, поэтому обычно невозможно предсказать порядок элементов в управляемой последовательности. Вставка элементов не делает итераторы недействительными, а при удалении элементов недействительными становятся только итераторы, которые ранее указывали конкретно на удаленные элементы.

Итератор, предоставляемый классом hash_set, является двунаправленным итератором, но функции-члены класса insert и hash_set имеют версии, которые принимают в качестве параметров-шаблонов более слабый итератор ввода, чьи функциональные требования ниже, чем гарантированные классом двунаправленных итераторов. Различные концепции итераторов образуют семейство, связанное уточнениями функциональности. Каждая концепция итератора имеет собственный набор требований, а алгоритмы, работающие с ними, должны ограничивать свои предположения согласно требованиям, предоставляемым этим типом итератора. Можно предположить, что итератор ввода может быть разыменован для обращения к определенному объекту и инкрементирован до следующего итератора в последовательности. Это минимальный набор функций, но его достаточно для осмысленного обсуждения диапазона итераторов [ first, last) в контексте функций-членов класса.

Конструкторы

Конструктор	Description
hash_set	Создает контейнер hash_set, который является пустым или копией части или целого другого контейнера hash_set.

Определения типов

Введите имя	Description
allocator_type	Тип, представляющий класс allocator для объекта hash_set.
const_iterator	Тип, предоставляющий двунаправленный итератор, который может считывать тот или иной элемент const в контейнере hash_set.
const_pointer	Тип, предоставляющий указатель на элемент const в контейнере hash_set.
const_reference	Тип, предоставляющий ссылку на элемент const, сохраненный в контейнере hash_set для чтения и выполнения операций const.
const_reverse_iterator	Тип, предоставляющий двунаправленный итератор, который может считывать любой элемент const в контейнере hash_set.
difference_type	Тип целого числа со знаком, пригодный для представления количества элементов в контейнере hash_set в диапазоне между элементами, на которые указывают итераторы.
iterator	Тип, предоставляющий двунаправленный итератор, который может считывать или изменять любой элемент в hash_set.
key_compare	Тип, предоставляющий объект функции, который может сравнить два ключа сортировки для определения относительного порядка двух элементов в контейнере hash_set.
key_type	Тип, описывающий объект, сохраненный как элемент hash_set в смысле его возможностей, присущих ключу сортировки.
pointer	Тип, предоставляющий указатель на элемент в hash_set.
reference	Тип, предоставляющий ссылку на элемент, хранящийся в контейнере hash_set.
reverse_iterator	Тип, предоставляющий двунаправленный итератор, который может считывать или изменять элемент в обращенном контейнере hash_set.
size_type	Целочисленный Typedef без знака, который может представлять число элементов в hash_set.
value_compare	Тип, который предоставляет два объекта функции, бинарный предикат сравнения классов, который может сравнить два значения элементов hash_set для определения их относительного порядка, и унарный предикат, хэширующий элементы.
value_type	Тип, описывающий объект, сохраненный как элемент hash_set в смысле его возможностей, присущих значению.

Функции элементов

Функция-член	Description
begin	Возвращает итератор, обращающийся к первому элементу в hash_set.
cbegin	Возвращает итератор const, обращающийся к первому элементу в hash_set.
cend	Возвращает итератор const, который обращается к месту, следующему за последним элементом в hash_set.
пусто	Стирает все элементы в hash_set.
count	Возвращает число элементов в контейнере hash_set, ключи которых соответствуют ключу, заданному параметром.
crbegin	Возвращает итератор const, который обращается к первому элементу в обращенном контейнере hash_set.
crend	Возвращает итератор const, который обращается к месту, следующему за последним элементом в обращенном контейнере hash_set.
emplace	Вставляет созданный на месте элемент в hash_set.
emplace_hint	Вставляет созданный на месте элемент в hash_set с подсказкой о размещении.
empty	Проверяет, пуст ли hash_set.
end	Возвращает итератор, который обращается к месту, следующему за последним элементом в контейнере hash_set.
equal_range	Возвращает пару итераторов соответственно на первый элемент в hash_set с ключом, который больше, чем указанный ключ, и на первый элемент в hash_set с ключом, который больше или равен данному ключу.
erase	Удаляет элемент или диапазон элементов в hash_set с заданных позиций или удаляет элементы, соответствующие заданному ключу.
find	Возвращает итератор, адресующий расположение элемента в наборе hash_set с ключом, эквивалентным указанному ключу.
get_allocator	Возвращает копию объекта allocator, который используется для создания контейнера hash_set.
insert	Вставляет элемент или диапазон элементов в hash_set.
key_comp	Извлекает копию объекта сравнения, который используется для упорядочивания ключей в контейнере hash_set.
lower_bound	Возвращает итератор, указывающий на первый элемент в hash_set с ключом, который больше или равен указанному ключу.
max_size	Возвращает максимальную длину hash_set.
rbegin	Возвращает итератор, который обращается к первому элементу в обращенном контейнере hash_set.
rend	Возвращает итератор, который обращается к месту, следующему за последним элементом в обращенном контейнере hash_set.
size	Возвращает количество элементов в контейнере hash_set.
swap	Выполняет обмен элементами между двумя объектами hash_set.
upper_bound	Возвращает итератор, указывающий на первый элемент в контейнере hash_set с ключом, который больше или равен указанному ключу.
value_comp	Извлекает копию объекта признаков хэша, используемого для хэширования и упорядочения значений ключей элемента в hash_set.

Операторы

Operator	Description
hash_set::operator=	Заменяет элементы hash_set копией другого hash_set.

Требования

Заголовок:<hash_set>

Пространство имен: stdext

hash_set::allocator_type

Тип, представляющий класс распределителя для объекта hash_set.

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

Замечания

allocator_type является синонимом параметра-шаблона Распределитель.

Дополнительные сведения об Allocator см. в разделе "Примечания" раздела "Класс hash_set".

Пример

См. пример для get_allocator в качестве примера использования allocator_type.

hash_set::begin

Возвращает итератор, адресующий первый элемент в hash_set.

const_iterator begin() const;

iterator begin();

Возвращаемое значение

Двунаправленный итератор, адресующий первый элемент в hash_set или положение после пустого hash_set.

Замечания

Если возвращаемое значение begin назначено объекту const_iterator, элементы в объекте hash_set нельзя изменить. Если возвращаемое значение begin назначено iteratorобъекту, элементы в объекте hash_set можно изменить.

Пример

// hash_set_begin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.begin( );
   cout << "The first element of hs1 is " << *hs1_Iter << endl;

   hs1_Iter = hs1.begin( );
   hs1.erase( hs1_Iter );

   // The following 2 lines would err because the iterator is const
   // hs1_cIter = hs1.begin( );
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.begin( );
   cout << "The first element of hs1 is now " << *hs1_cIter << endl;
}

The first element of hs1 is 1
The first element of hs1 is now 2

hash_set::cbegin

Возвращает константный итератор, адресующий первый элемент в hash_set.

const_iterator cbegin() const;

Возвращаемое значение

Константный двунаправленный итератор, адресующий первый элемент в hash_set или положение после пустого hash_set.

Замечания

Если возвращенное значение — cbegin, элементы в объекте hash_set изменить нельзя.

Пример

// hash_set_cbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cbegin( );
   cout << "The first element of hs1 is " << *hs1_cIter << endl;
}

The first element of hs1 is 1

hash_set::cend

Возвращает константный итератор, который адресует положение после последнего элемента в hash_map.

const_iterator cend() const;

Возвращаемое значение

Константный двунаправленный итератор, адресующий положение после последнего элемента в hash_set. Если hash_set является пустым, то hash_set::cend == hash_set::begin.

Замечания

cend используется для проверки, достиг ли итератор конца своего hash_set. Значение, возвращаемое cend, не должно быть подвергнуто удалению ссылки.

Пример

// hash_set_cend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_cIter = hs1.cend( );
   hs1_cIter--;
   cout << "The last element of hs1 is " << *hs1_cIter << endl;
}

The last element of hs1 is 3

hash_set::clear

Стирает все элементы в объекте hash_set.

void clear();

Замечания

Пример

// hash_set_clear.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 1 );
   hs1.insert( 2 );

   cout << "The size of the hash_set is initially " << hs1.size( )
        << "." << endl;

   hs1.clear( );
   cout << "The size of the hash_set after clearing is "
        << hs1.size( ) << "." << endl;
}

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

hash_set::const_iterator

Тип, предоставляющий двунаправленный итератор, который может считывать const элемент в hash_set.

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

Замечания

Тип const_iteratorнельзя использовать для изменения значения элемента.

Пример

См. пример для begin в качестве примера использования const_iterator.

hash_set::const_pointer

Тип, предоставляющий указатель на const элемент в hash_set.

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

Замечания

Тип const_pointerнельзя использовать для изменения значения элемента.

В большинстве случаев const_iterator следует использовать для доступа к элементам в объекте const hash_set.

hash_set::const_reference

Тип, предоставляющий ссылку на const элемент, хранящийся в hash_set для чтения и выполнения const операций.

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

Замечания

Пример

// hash_set_const_ref.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference cannot be used to modify the hash_set
   // Ref1 = Ref1 + 5;
}

The first element in the hash_set is 10.

hash_set::const_reverse_iterator

Тип, предоставляющий двунаправленный итератор, который может считывать любой const элемент в hash_set.

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

Замечания

Тип const_reverse_iterator не может изменять значение элемента и используется для перебора hash_set в обратном порядке.

Пример

См. пример для rend в качестве примера объявления и использования const_reverse_iterator

hash_set::count

Возвращает число элементов в объекте hash_set, ключ которых совпадает с ключом, заданным параметром.

size_type count(const Key& key) const;

Параметры

key
Ключ для сравнения с ключами элементов объекта hash_set.

Возвращаемое значение

1, если объект hash_set содержит элемент, ключ сортировки которого совпадает с ключом параметра.

0, если объект hash_set не содержит ни одного элемента с совпадающим ключом.

Замечания

Функция-член возвращает число элементов в следующем диапазоне:

[ lower_bound(ключ), upper_bound(ключ).

Пример

В следующем примере демонстрируется использование функции-члена hash_set::count.

// hash_set_count.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1;
    hash_set<int>::size_type i;

    hs1.insert(1);
    hs1.insert(1);

    // Keys must be unique in hash_set, so duplicates are ignored.
    i = hs1.count(1);
    cout << "The number of elements in hs1 with a sort key of 1 is: "
         << i << "." << endl;

    i = hs1.count(2);
    cout << "The number of elements in hs1 with a sort key of 2 is: "
         << i << "." << endl;
}

The number of elements in hs1 with a sort key of 1 is: 1.
The number of elements in hs1 with a sort key of 2 is: 0.

hash_set::crbegin

Возвращает константный итератор, адресующий первый элемент в обратном hash_set.

const_reverse_iterator crbegin() const;

Возвращаемое значение

Константный обратный двунаправленный итератор, адресующий первый элемент в обратном hash_set или элемент, который был последним элементом в hash_set до изменения его порядка на противоположный.

Замечания

crbegin используется с обратным hash_set так же, как hash_set::begin используется с обычным hash_set.

Если возвращаемое значение crbegin, то объект hash_set невозможно изменить.

crbegin можно использовать для перебора hash_set в обратном порядке.

Пример

// hash_set_crbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The first element in the reversed hash_set is 30.

hash_set::crend

Возвращает константный итератор, адресующий положение после последнего элемента в обратном hash_set.

const_reverse_iterator crend() const;

Возвращаемое значение

Константный обратный двунаправленный итератор, адресующий положение после последнего элемента в обратном hash_set (положение перед первым элементом в hash_set до изменения его порядка на противоположный).

Замечания

crend используется с обратным hash_set так же, как hash_set::end используется с обычным hash_set.

Если возвращаемое значение crend, то объект hash_set невозможно изменить.

crend используется, чтобы проверить, достиг ли итератор конца hash_set.

Пример

// hash_set_crend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_crIter = hs1.crend( );
   hs1_crIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_crIter << "." << endl;
}

The last element in the reversed hash_set is 10.

hash_set::d ifference_type

Целочисленный тип со знаком, который можно использовать для представления количества элементов в hash_set в диапазоне между элементами, на которые указывают итераторы.

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

Замечания

difference_type — тип, возвращаемый при вычитании или приращении через итераторы контейнера. difference_type обычно используется для представления количества элементов в диапазоне [ first, last) между итераторами first и last, включая элемент, на который указывает first, и диапазон элементов до, но не включая элемент, на который указывает last.

Обратите внимание, что хотя difference_type доступно для всех итераторов, соответствующих требованиям итератора ввода, что включает класс двунаправленных итераторов, поддерживаемых обратимыми контейнерами, например наборами, вычитание между итераторами поддерживается только итераторами произвольного доступа, предоставляемыми контейнерами произвольного доступа, например vector или deque.

Пример

// hash_set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <hash_set>
#include <algorithm>

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

   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter, hs1_bIter, hs1_eIter;

   hs1.insert( 20 );
   hs1.insert( 10 );
   hs1.insert( 20 );   // Won't insert as hash_set elements are unique

   hs1_bIter = hs1.begin( );
   hs1_eIter = hs1.end( );

   hash_set <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( hs1_bIter, hs1_eIter, 5 );
   df_typ10 = count( hs1_bIter, hs1_eIter, 10 );
   df_typ20 = count( hs1_bIter, hs1_eIter, 20 );

   // The keys, and hence the elements, of a hash_set are unique,
   // so there is at most one of a given value
   cout << "The number '5' occurs " << df_typ5
        << " times in hash_set hs1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in hash_set hs1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in hash_set hs1.\n";

   // Count the number of elements in a hash_set
   hash_set <int>::difference_type  df_count = 0;
   hs1_Iter = hs1.begin( );
   while ( hs1_Iter != hs1_eIter)
   {
      df_count++;
      hs1_Iter++;
   }

   cout << "The number of elements in the hash_set hs1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in hash_set hs1.
The number '10' occurs 1 times in hash_set hs1.
The number '20' occurs 1 times in hash_set hs1.
The number of elements in the hash_set hs1 is: 2.

hash_set::emplace

Вставляет в hash_set элемент, созданный на месте.

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

Параметры

Val
Значение элемента для вставки в hash_set, если hash_set уже не содержит этот элемент, или, в более общем случае, элемент, ключ которого эквивалентно упорядочен.

Возвращаемое значение

Функция-член emplace возвращает пару, bool компонент которой возвращает true, если вставка была выполнена, и false, если hash_set уже содержал элемент, ключ которого имел эквивалентное значение упорядочивания и чей компонент-итератор возвращает адрес вставки нового элемента или адрес уже существовавшего элемента.

Замечания

Пример

// hash_set_emplace.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.emplace(move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::emplace_hint

Вставляет в hash_set элемент, созданный на месте.

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

Параметры

Val
Значение элемента для вставки в hash_set, если hash_set уже не содержит этот элемент, или, в более общем случае, элемент, ключ которого эквивалентно упорядочен.

_Где
Место начала поиска правильной точки вставки. (Вставка может происходить в амортизированном времени константы вместо логарифмического времени, если точка вставки немедленно следует _Where.)

Возвращаемое значение

Функция-член hash_set::emplace возвращает итератор, указывающий на позицию вставки нового элемента в hash_set или на позицию, где находится существующий элемент с эквивалентным порядком.

Замечания

Вставка может происходить в амортизированном времени константы вместо логарифмического времени, если точка вставки немедленно следует _Where.

Пример

// hash_set_emplace_hint.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<string> hs3;
   string str1("a");

   hs3.insert(hs3.begin(), move(str1));
   cout << "After the emplace insertion, hs3 contains "
      << *hs3.begin() << "." << endl;
}

After the emplace insertion, hs3 contains a.

hash_set::empty

Проверяет, что hash_set пуст.

bool empty() const;

Возвращаемое значение

true Значение hash_set, если hash_set пуст; false Значение , если hash_set не является непустимой.

Замечания

Пример

// hash_set_empty.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2;
   hs1.insert ( 1 );

   if ( hs1.empty( ) )
      cout << "The hash_set hs1 is empty." << endl;
   else
      cout << "The hash_set hs1 is not empty." << endl;

   if ( hs2.empty( ) )
      cout << "The hash_set hs2 is empty." << endl;
   else
      cout << "The hash_set hs2 is not empty." << endl;
}

The hash_set hs1 is not empty.
The hash_set hs2 is empty.

hash_set::end

Возвращает итератор, адресующий положение после последнего элемента в hash_set.

const_iterator end() const;

iterator end();

Возвращаемое значение

Двунаправленный итератор, адресующий положение после последнего элемента в hash_set. Если hash_set пуст, то hash_set::end == hash_set::begin.

Замечания

end используется для проверки того, достиг ли итератор конца hash_set. Значение, возвращаемое end, не должно быть подвергнуто удалению ссылки.

Пример

// hash_set_end.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: iterator hs1_Iter;
   hash_set <int> :: const_iterator hs1_cIter;

   hs1.insert( 1 );
   hs1.insert( 2 );
   hs1.insert( 3 );

   hs1_Iter = hs1.end( );
   hs1_Iter--;
   cout << "The last element of hs1 is " << *hs1_Iter << endl;

   hs1.erase( hs1_Iter );

   // The following 3 lines would err because the iterator is const:
   // hs1_cIter = hs1.end( );
   // hs1_cIter--;
   // hs1.erase( hs1_cIter );

   hs1_cIter = hs1.end( );
   hs1_cIter--;
   cout << "The last element of hs1 is now " << *hs1_cIter << endl;
}

The last element of hs1 is 3
The last element of hs1 is now 2

hash_set::equal_range

Возвращает пару итераторов, указывающих на первый элемент в hash_set с ключом, равным указанному, и на первый элемент в hash_set с ключом, который больше указанного.

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

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

Параметры

key
Ключ-аргумент, который будет сравниваться с ключом сортировки элемента из hash_set, в котором выполняется поиск.

Возвращаемое значение

Пара итераторов, первый из которых — lower_bound ключа, а второй — upper_bound ключа.

Доя получения доступа к первому итератору в паре, возвращаемой функцией-членом, используйте pr. во-первых, и для разыменовки нижнего итератора итератора используйте *( pr. сначала). Для доступа к второму итератору пары pr, возвращаемой функцией-членом, нужно использовать pr. во-вторых, и для разыменовки итератора верхнего границы используйте *( pr. во-вторых).

Замечания

Пример

// hash_set_equal_range.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   typedef hash_set<int> IntHSet;
   IntHSet hs1;
   hash_set <int> :: const_iterator hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   pair <IntHSet::const_iterator, IntHSet::const_iterator> p1, p2;
   p1 = hs1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the hash_set hs1 is: "
        << *(p1.first) << "." << endl;

   // Compare the upper_bound called directly
   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *hs1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = hs1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == hs1.end( ) ) && ( p2.second == hs1.end( ) ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than or equal to 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key >= 40 is: "
           << *(p1.first) << "." << endl;
}

The upper bound of the element with a key of 20 in the hash_set hs1 is: 30.
The lower bound of the element with a key of 20 in the hash_set hs1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The hash_set hs1 doesn't have an element with a key greater than or equal to 40.

hash_set::erase

Удаляет элемент или диапазон элементов в объекте hash_set с заданных позиций или удаляет элементы, соответствующие заданному ключу.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

size_type erase(const key_type& key);

Параметры

_Где
Положение элемента, удаляемого из объекта hash_set.

first
Положение первого элемента, удаляемого из объекта hash_set.

last
Положение сразу после последнего элемента, удаляемого из объекта hash_set.

key
Ключ элементов, удаляемых из объекта hash_set.

Возвращаемое значение

Для первых двух функций-членов двунаправленный итератор, указывающий на первый элемент, оставшийся после удаления элементов, или на указатель конца объекта hash_set, если такого элемента не существует. Для третьей функции-члена число элементов, удаленных из объекта hash_set.

Замечания

Функции-члены не создают исключений.

Пример

В следующем примере демонстрируется использование функции-члена hash_set::erase.

// hash_set_erase.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main()
{
    using namespace std;
    using namespace stdext;
    hash_set<int> hs1, hs2, hs3;
    hash_set<int>::iterator pIter, Iter1, Iter2;
    int i;
    hash_set<int>::size_type n;

    for (i = 1; i < 5; i++)
    {
        hs1.insert (i);
        hs2.insert (i * i);
        hs3.insert (i - 1);
    }

    // The 1st member function removes an element at a given position
    Iter1 = ++hs1.begin();
    hs1.erase(Iter1);

    cout << "After the 2nd element is deleted, the hash_set hs1 is:";
    for (pIter = hs1.begin(); pIter != hs1.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 2nd member function removes elements
    // in the range [ first,  last)
    Iter1 = ++hs2.begin();
    Iter2 = --hs2.end();
    hs2.erase(Iter1, Iter2);

    cout << "After the middle two elements are deleted, "
         << "the hash_set hs2 is:";
    for (pIter = hs2.begin(); pIter != hs2.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function removes elements with a given  key
    n = hs3.erase(2);

    cout << "After the element with a key of 2 is deleted, "
         << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;

    // The 3rd member function returns the number of elements removed
    cout << "The number of elements removed from hs3 is: "
         << n << "." << endl;

    // The dereferenced iterator can also be used to specify a key
    Iter1 = ++hs3.begin();
    hs3.erase(Iter1);

    cout << "After another element (unique for hash_set) with a key "
         << endl;
    cout  << "equal to that of the 2nd element is deleted, "
          << "the hash_set hs3 is:";
    for (pIter = hs3.begin(); pIter != hs3.end(); pIter++)
        cout << " " << *pIter;
    cout << "." << endl;
}

After the 2nd element is deleted, the hash_set hs1 is: 1 3 4.
After the middle two elements are deleted, the hash_set hs2 is: 16 4.
After the element with a key of 2 is deleted, the hash_set hs3 is: 0 1 3.
The number of elements removed from hs3 is: 1.
After another element (unique for hash_set) with a key
equal to that of the 2nd element is deleted, the hash_set hs3 is: 0 3.

hash_set::find

Возвращает итератор, адресующий положение элемента в hash_set с ключом, эквивалентным указанному.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Параметры

key
Ключ-аргумент для сопоставления с ключом сортировки элемента из hash_set, в котором выполняется поиск.

Возвращаемое значение

const_iterator Объект iterator или адрес расположения элемента, эквивалентного указанному ключу или адресующий расположение, успешное выполнение последнего элемента в hash_set, если совпадение не найдено для ключа.

Замечания

Функция-член возвращает итератор, который обращается к элементу в hash_set, ключ сортировки которого является equivalent ключом аргумента в двоичном предикате, который вызывает упорядочение на основе отношения сравнения меньше, чем сравнение.

Если возвращаемое значение find назначено объекту const_iterator, hash_set объект нельзя изменить. Если возвращаемое значение find назначено iteratorобъекту, hash_set объект можно изменить.

Пример

// hash_set_find.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.find( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.find( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // The element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.find( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::get_allocator

Возвращает копию распределителя, использованного для создания hash_set.

Allocator get_allocator() const;

Возвращаемое значение

Распределитель, используемый hash_set для управления памятью, который является параметром шаблона Allocator.

Дополнительные сведения об Allocator см. в разделе "Примечания" раздела "Класс hash_set".

Замечания

Распределители для класса hash_set определяют, как класс управляет памятью. Распределители по умолчанию для классов контейнеров из стандартной библиотеки C++ достаточны для большинства задач программирования. Написание и использование собственного класса распределителя требует расширенных навыков работы с C++.

Пример

// hash_set_get_allocator.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

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

   // The following lines declare objects
   // that use the default allocator.
   hash_set <int, hash_compare <int, less<int> > > hs1;
   hash_set <int,  hash_compare <int, greater<int> > > hs2;
   hash_set <double, hash_compare <double,
      less<double> >, allocator<double> > hs3;

   hash_set <int, hash_compare <int,
      greater<int> > >::allocator_type hs2_Alloc;
   hash_set <double>::allocator_type hs3_Alloc;
   hs2_Alloc = hs2.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs1.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << hs3.max_size( ) <<  "." << endl;

   // The following lines create a hash_set hs4
   // with the allocator of hash_set hs1.
   hash_set <int>::allocator_type hs4_Alloc;
   hash_set <int> hs4;
   hs4_Alloc = hs2.get_allocator( );

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

hash_set::hash_set

Создает контейнер hash_set, который является пустым или копией части или целого другого контейнера hash_set.

hash_set();

explicit hash_set(
    const Traits& Comp);

hash_set(
    const Traits& Comp,
    const Allocator& Al);

hash_set(
    const hash_set<Key, Traits, Allocator>& Right);

hash_set(
    hash_set&& Right);

hash_set(
    initializer_list<Type> IList);

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

hash_set(
    initializer_list<value_type> IList,
    const Compare& Comp,
    const Allocator& Al);

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

template <class InputIterator>
hash_set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

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

Параметры

Аль
Класс распределителя памяти для использования с этим объектом hash_set. Значение по умолчанию — Allocator.

Комп
Функция сравнения типа const Traits, используемая для упорядочивания элементов в hash_set. Значение по умолчанию — hash_compare.

Right
hash_set, копией которого будет создаваемый hash_set.

First
Положение первого элемента в диапазоне копируемых элементов.

Последняя
Положение первого элемента после диапазона копируемых элементов.

Замечания

Все конструкторы хранят тип объекта-распределителя, управляющего памятью для hash_set. Позже этот объект можно получить путем вызова hash_set::get_allocator. Параметр распределителя часто опускается в объявлениях классов и макросах предварительной обработки, используемых для замены альтернативных распределителей.

Все конструкторы инициализируют свои объекты hash_set.

Все конструкторы хранят объект-функцию типа Traits, используемую для установления порядка ключей hash_set. Позже эту функцию можно получить путем вызова hash_set::key_comp. Более подробные сведения по Traits см. в разделе Класс hash_set.

Первый конструктор создает пустой начальный hash_set. Второй указывает тип функции сравнения ( Comp) для использования при определении порядка элементов. Третий явно указывает тип распределителя ( Al) для использования. Ключевое слово explicit подавляет некоторые виды автоматического преобразования типов.

Четвертый и пятый конструкторы указывают копию hash_set Right.

Шестой, седьмой и восьмой конструкторы используют для создания элементов объект initializer_list.

Последние конструкторы копирую диапазон [ First, Last) hash_set с повышением точности при указании типа функции сравнения класса Traits и распределителя.

Восьмой конструктор перемещает hash_set Right.

Фактический порядок элементов в контейнере hash_set зависит от функции хэша, функции упорядочивания и текущего размера хэш-таблицы и, в общем случае, не может быть предсказан, как в случае с контейнером типа набор, где он определяется только функцией упорядочивания.

hash_set::insert

Вставляет элемент или диапазон элементов в hash_set.

pair<iterator, bool> insert(
    const value_type& Val);

iterator insert(
    iterator Where,
    const value_type& Val);

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

Параметры

Валь
Значение элемента для вставки в hash_set, кроме случая, когда hash_set уже содержит этот элемент или, в более общем смысле, элемент, чей ключ имеет эквивалентный порядок.

Where
Место начала поиска правильной точки вставки. (Вставка может происходить в амортизированном константном времени вместо логарифмического времени, если точка вставки следует сразу за _Where.)

First
Позиция первого элемента для копирования из hash_set.

Последняя
Позиция сразу после последнего элемента для копирования из hash_set.

IList
Объект initializer_list, из которого копируются элементы.

Возвращаемое значение

Первая функция-член insert возвращает пару, bool компонент которой возвращает true, если вставка была выполнена, и false, если в hash_set уже содержался элемент с ключом, имеющим эквивалентное значение в упорядочивании, а компонент-итератор возвращает адрес вставки нового элемента или адрес расположения существующего элемента.

Для доступа к компоненту-итератору пары pr, возвращаемой этой функцией-членом, используйте pr.first, а для его разыменования — *(pr.first). Для доступа к компоненту bool пары pr, возвращенной этой функцией-членом, используйте pr.second и разыменуйте ее с помощью *(pr.second).

Вторая функция-член insert возвращает итератор, указывающий на позицию, где новый элемент был вставлен в hash_set.

Замечания

Третья функция-член вставляет элементы из объекта initializer_list.

Третья функция-член вставляет последовательность значений элементов в hash_set в соответствии с каждым элементом, адресованным итератором в диапазоне [ First, Last) указанного hash_set.

hash_set::iterator

Тип, предоставляющий двунаправленный итератор, который может читать или изменять любой элемент в hash_set.

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

Замечания

Тип iterator можно использовать для изменения значения элемента.

Пример

См. пример объявления и использования iterator см. в разделе begin.

hash_set::key_comp

Извлекает копию объекта признаков хэша, которая используется для хэширования и упорядочивания ключевых значений элементов в hash_set.

key_compare key_comp() const;

Возвращаемое значение

Возвращает объект функции, который hash_set использует для упорядочивания его элементов, который является признаком параметра шаблона.

Дополнительные сведения о признаках см. в разделе hash_set класса.

Замечания

Сохраненный объект определяет функцию-член:

bool operator( const Key& _xVal, const Key& _yVal );

значение , которое возвращается true , если _xVal предшествует и не равно _yVal в порядке сортировки.

Обратите внимание, что и key_compare, и value_compare — синонимы параметра-шаблона Traits. Оба типа предоставляются для классов hash_set и hash_multiset, где они идентичны, для совместимости с классами hash_map и hash_multimap, где они различаются.

Пример

// hash_set_key_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

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

   hash_set <int, hash_compare < int, less<int> > >hs1;
   hash_set<int, hash_compare < int, less<int> > >::key_compare kc1
          = hs1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of hs1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of hs1."
        << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::key_compare
         kc2 = hs2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if(result2 == true)
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of hs2."
           << endl;
   }
}

hash_set::key_compare

Тип, который предоставляет объект-функцию, которая может сравнить два ключа сортировки для определения относительного порядка двух элементов в hash_set.

typedef Traits key_compare;

Замечания

key_compare является синонимом для параметров шаблона.

Дополнительные сведения о признаках см. в разделе hash_set класса.

Обратите внимание, что и key_compare, и value_compare — синонимы параметра-шаблона Traits. Оба типа предоставляются для классов set и multiset, где они идентичны, для совместимости с классами map и multimap, где они различаются.

Пример

См. пример для key_comp в качестве примера объявления и использования key_compare.

hash_set::key_type

Тип, описывающий объект, который хранится в качестве элемента hash_set в смысле его возможностей как ключа сортировки.

typedef Key key_type;

Замечания

key_typeявляется синонимом ключа параметра шаблона.

Дополнительные сведения о ключе см. в разделе "Примечания" раздела класса hash_set.

Обратите внимание, что и key_type, и value_type — синонимы для параметра-шаблона Key. Оба типа предоставляются для классов hash_set и hash_multiset, где они идентичны, для совместимости с классами hash_map и hash_multimap, где они различаются.

Пример

См. пример для value_type в качестве примера объявления и использования key_type.

hash_set::lower_bound

Возвращает итератор, указывающий на первый элемент в hash_set с ключом, который больше указанного ключа или равен ему.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Параметры

key
Ключ-аргумент, который будет сравниваться с ключом сортировки элемента из hash_set, в котором выполняется поиск.

Возвращаемое значение

const_iterator Объект iterator или адресирует расположение элемента в hash_set, что с ключом, равным или больше ключа аргумента, или адресует расположение, успешное выполнение последнего элемента в hash_set, если совпадение не найдено для ключа.

Замечания

Пример

// hash_set_lower_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.lower_bound( 20 );
   cout << "The element of hash_set hs1 with a key of 20 is: "
        << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of hash_set hs1 with a key of 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator that addresses the location
   hs1_AcIter = hs1.end( );
   hs1_AcIter--;
   hs1_RcIter = hs1.lower_bound( *hs1_AcIter );
   cout << "The element of hs1 with a key matching "
        << "that of the last element is: "
        << *hs1_RcIter << "." << endl;
}

The element of hash_set hs1 with a key of 20 is: 20.
The hash_set hs1 doesn't have an element with a key of 40.
The element of hs1 with a key matching that of the last element is: 30.

hash_set::max_size

Возвращает максимальную длину hash_set.

size_type max_size() const;

Возвращаемое значение

Максимально возможная длина hash_set.

Замечания

Пример

// hash_set_max_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::size_type i;

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

hash_set::operator=

Заменяет элементы hash_set копией другого hash_set.

hash_set& operator=(const hash_set& right);

hash_set& operator=(hash_set&& right);

Параметры

right
Hash_set, который будет копироваться в hash_set.

Замечания

После удаления существующих элементов в объекте hash_setкопирует operator= или перемещает содержимое вправоhash_set.

Пример

// hash_set_operator_as.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set<int> v1, v2, v3;
   hash_set<int>::iterator iter;

   v1.insert(10);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << iter << " ";
   cout << endl;
}

hash_set::p ointer

Тип, предоставляющий указатель на элемент в hash_set.

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

Замечания

Тип pointer можно использовать для изменения значения элемента.

В большинстве случаев для доступа к элементам в объекте hash_set следует использовать iterator.

hash_set::rbegin

Возвращает итератор, адресующий первый элемент в обратном hash_set.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Возвращаемое значение

Обратный двунаправленный итератор, адресующий первый элемент в обратном hash_set или элемент, который был последним элементов в hash_set до изменения его порядка на противоположный.

Замечания

rbegin используется с обратным hash_set так же, как begin используется с обычным hash_set.

Если возвращенное значение rbegin назначается const_reverse_iterator, то объект hash_set изменить нельзя. Если возвращенное значение rbegin назначается reverse_iterator, то объект hash_set можно изменить.

rbegin можно использовать для перебора hash_set в обратном порядке.

Пример

// hash_set_rbegin.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rbegin( );
   cout << "The first element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << endl;

   // rbegin can be used to start an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << endl;

   // A hash_set element can be erased by dereferencing to its key
   hs1_rIter = hs1.rbegin( );
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed hash_set is "<< *hs1_rIter << "."
        << endl;
}

The first element in the reversed hash_set is 30.
The hash_set is: 10 20 30
The reversed hash_set is: 30 20 10
After the erasure, the first element in the reversed hash_set is 20.

hash_set::reference

Тип, который предоставляет ссылку на элемент, хранящийся в hash_set.

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

Замечания

Пример

// hash_set_reference.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;

   hs1.insert( 10 );
   hs1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   int &Ref1 = *hs1.begin( );

   cout << "The first element in the hash_set is "
        << Ref1 << "." << endl;

   // The value of the 1st element of the hash_set can be changed
   // by operating on its (non-const) reference
   Ref1 = Ref1 + 5;

   cout << "The first element in the hash_set is now "
        << *hs1.begin() << "." << endl;
}

The first element in the hash_set is 10.
The first element in the hash_set is now 15.

hash_set::rend

Возвращает итератор, адресующий положение после последнего элемента в обратном hash_set.

const_reverse_iterator rend() const;

reverse_iterator rend();

Возвращаемое значение

Обратный двунаправленный итератор, адресующий положение после последнего элемента в обратном hash_set (положение перед первым элементом hash_set до изменения его порядка на противоположный).

Замечания

rend используется с обратным hash_set так же, как end используется с обычным hash_set.

Если возвращенное значение rend назначается const_reverse_iterator, то объект hash_set изменить нельзя. Если возвращенное значение rend назначается reverse_iterator, то объект hash_set можно изменить. Значение, возвращаемое rend, не должно быть подвергнуто удалению ссылки.

rend можно использовать для проверки, достиг ли обратный итератор конца своего объекта hash_set.

Пример

// hash_set_rend.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;
   hash_set <int>::reverse_iterator hs1_rIter;
   hash_set <int>::const_reverse_iterator hs1_crIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "The last element in the reversed hash_set is "
        << *hs1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a hash_set in a forward order
   cout << "The hash_set is: ";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( );
         hs1_Iter++ )
      cout << *hs1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a hash_set in a reverse order
   cout << "The reversed hash_set is: ";
   for ( hs1_rIter = hs1.rbegin( ) ; hs1_rIter != hs1.rend( );
         hs1_rIter++ )
      cout << *hs1_rIter << " ";
   cout << "." << endl;

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   hs1.erase ( *hs1_rIter );

   hs1_rIter = hs1.rend( );
   hs1_rIter--;
   cout << "After the erasure, the last element in the "
        << "reversed hash_set is " << *hs1_rIter << "."
        << endl;
}

The last element in the reversed hash_set is 10.
The hash_set is: 10 20 30 .
The reversed hash_set is: 30 20 10 .
After the erasure, the last element in the reversed hash_set is 20.

hash_set::reverse_iterator

Тип, предоставляющий двунаправленный итератор, который может читать или изменять элементы в обратном hash_set.

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

Замечания

Тип reverse_iterator используется для перебора hash_set в обратном порядке.

Пример

См. пример объявления и использования reverse_iterator в примере для rbegin.

hash_set::size

Возвращает количество элементов в объекте hash_set.

size_type size() const;

Возвращаемое значение

Текущая длина объекта hash_set.

Замечания

Пример

// hash_set_size.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: size_type i;

   hs1.insert( 1 );
   i = hs1.size( );
   cout << "The hash_set length is " << i << "." << endl;

   hs1.insert( 2 );
   i = hs1.size( );
   cout << "The hash_set length is now " << i << "." << endl;
}

The hash_set length is 1.
The hash_set length is now 2.

hash_set::size_type

Беззнаковый целочисленный тип, который может представлять количество элементов в объекте hash_set.

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

Замечания

Пример

См. пример для size в качестве примера объявления и использования size_type

hash_set::swap

Выполняет обмен элементами между двумя объектами hash_set.

void swap(hash_set& right);

Параметры

right
Объект-аргумент hash_set, содержащий элементы, которые нужно поменять местами с объектами в целевом объекте hash_set.

Замечания

Функция-член не делает недействительными никакие ссылки, указатели или итераторы, обозначающие элементы в двух объектах hash_set, которые меняются элементами.

Пример

// hash_set_swap.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1, hs2, hs3;
   hash_set <int>::iterator hs1_Iter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );
   hs2.insert( 100 );
   hs2.insert( 200 );
   hs3.insert( 300 );

   cout << "The original hash_set hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   hs1.swap( hs2 );

   cout << "After swapping with hs2, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( hs1, hs3 );

   cout << "After swapping with hs3, list hs1 is:";
   for ( hs1_Iter = hs1.begin( ); hs1_Iter != hs1.end( );
         hs1_Iter++ )
         cout << " " << *hs1_Iter;
   cout   << "." << endl;
}

The original hash_set hs1 is: 10 20 30.
After swapping with hs2, list hs1 is: 200 100.
After swapping with hs3, list hs1 is: 300.

hash_set::upper_bound

Возвращает итератор, указывающий на первый элемент в hash_set, ключ которого больше указанного ключа.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Параметры

key
Ключ-аргумент, который будет сравниваться с ключом сортировки элемента из hash_set, в котором выполняется поиск.

Возвращаемое значение

const_iterator Или iterator адресирует расположение элемента в hash_set, что с ключом, равным или больше ключа аргумента, или адресирует расположение, успешное выполнение последнего элемента в hash_set если совпадение не найдено для ключа.

Замечания

Пример

// hash_set_upper_bound.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int> :: const_iterator hs1_AcIter, hs1_RcIter;

   hs1.insert( 10 );
   hs1.insert( 20 );
   hs1.insert( 30 );

   hs1_RcIter = hs1.upper_bound( 20 );
   cout << "The first element of hash_set hs1 with a key greater "
        << "than 20 is: " << *hs1_RcIter << "." << endl;

   hs1_RcIter = hs1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( hs1_RcIter == hs1.end( ) )
      cout << "The hash_set hs1 doesn't have an element "
           << "with a key greater than 30." << endl;
   else
      cout << "The element of hash_set hs1 with a key > 40 is: "
           << *hs1_RcIter << "." << endl;

   // An element at a specific location in the hash_set can be found
   // by using a dereferenced iterator addressing the location
   hs1_AcIter = hs1.begin( );
   hs1_RcIter = hs1.upper_bound( *hs1_AcIter );
   cout << "The first element of hs1 with a key greater than "
        << endl << "that of the initial element of hs1 is: "
        << *hs1_RcIter << "." << endl;
}

The first element of hash_set hs1 with a key greater than 20 is: 30.
The hash_set hs1 doesn't have an element with a key greater than 30.
The first element of hs1 with a key greater than
that of the initial element of hs1 is: 20.

hash_set::value_comp

Извлекает копию объекта сравнения, используемого для упорядочивания элементов в объекте hash_set.

value_compare value_comp() const;

Возвращаемое значение

Возвращает объект функции, который hash_set использует для упорядочивания его элементов, который является параметром шаблона Compare.

Дополнительные сведения о сравнении см. в разделе "Примечания" раздела класса hash_set.

Замечания

Сохраненный объект определяет функцию-член:

bool operator( const Key& _xVal, const Key& _yVal );

значение , которое возвращается true , если _xVal предшествует и не равно _yVal в порядке сортировки.

Обратите внимание, что оба value_compare и key_compare являются синонимами для параметра шаблона Compare. Оба типа предоставляются для классов hash_set и hash_multiset, где они идентичны, для совместимости с классами hash_map и hash_multimap, где они различаются.

Пример

// hash_set_value_comp.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

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

   hash_set <int, hash_compare < int, less<int> > > hs1;
   hash_set <int, hash_compare < int, less<int> >  >::value_compare
      vc1 = hs1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of hs1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of hs1."
           << endl;
   }

   hash_set <int, hash_compare < int, greater<int> > > hs2;
   hash_set<int, hash_compare < int, greater<int> > >::value_compare
      vc2 = hs2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of hs2."
           << endl;
   }
}

hash_set::value_compare

Тип, который предоставляет два объекта-функции — бинарный предикат класса compare, который сравнивает значения двух элементов объекта hash_set для определения их относительного порядка, и унарный предикат, хэширующий элементы.

typedef key_compare value_compare;

Замечания

value_compare является синонимом для параметров шаблона.

Дополнительные сведения о признаках см. в разделе hash_set класса.

Обратите внимание, что оба key_compare и value_compare являются синонимами для параметров шаблона. Оба типа предоставляются для классов hash_set и hash_multiset, где они идентичны, для совместимости с классами hash_map и hash_multimap, где они различаются.

Пример

См. пример для value_comp в качестве примера объявления и использования value_compare.

hash_set::value_type

Тип, описывающий объект, хранящийся в качестве элемента объекта hash_set в смысле его возможностей как значения.

typedef Key value_type;

Пример

// hash_set_value_type.cpp
// compile with: /EHsc
#include <hash_set>
#include <iostream>

int main( )
{
   using namespace std;
   using namespace stdext;
   hash_set <int> hs1;
   hash_set <int>::iterator hs1_Iter;

   hash_set <int> :: value_type hsvt_Int;   // Declare value_type
   hsvt_Int = 10;             // Initialize value_type

   hash_set <int> :: key_type hskt_Int;   // Declare key_type
   hskt_Int = 20;             // Initialize key_type

   hs1.insert( hsvt_Int );         // Insert value into hs1
   hs1.insert( hskt_Int );         // Insert key into hs1

   // A hash_set accepts key_types or value_types as elements
   cout << "The hash_set has elements:";
   for ( hs1_Iter = hs1.begin( ) ; hs1_Iter != hs1.end( ); hs1_Iter++)
      cout << " " << *hs1_Iter;
   cout << "." << endl;
}

The hash_set has elements: 10 20.

См. также

Потокобезопасность в стандартной библиотеке C++
Справочник по стандартной библиотеке C++