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

В следующей таблице мы полагаем, что X - контейнерный класс, содержащий объекты типа T, a и b - значения X, u - идентификатор, r - значение X&.

Таблица 8. Требования контейнеров

Функция-член size() возвращает число элементов в контейнере. Её семантика определяется правилами конструкторов, вставок и удалений.

begin() возвращает итератор, ссылающийся на первый элемент в контейнере. end() возвращает итератор, который является законечным.

Если тип итератора контейнера принадлежит к категории двунаправленных итераторов или итераторов произвольного доступа, то контейнер называется reversible (обратимым) и удовлетворяет следующим дополнительным требованиям:

Таблица 9. Требования обратимых контейнеров (в дополнение к контейнерам)

Последовательность - это вид контейнера, который организует конечное множество объектов одного и того же типа в строгом линейном порядке. Библиотека обеспечивает три основных вида последовательных контейнеров: vector (вектор), list (список) и deque (двусторонняя очередь). Она также предоставляет контейнерные адаптеры, которые облегчают создание абстрактных типов данных, таких как стеки или очереди, из основных видов последовательностей (или из других видов последовательностей, которые пользователь может сам определить).

В следующих двух таблицах X - последовательный класс, a - значение X, i и j удовлетворяют требованиям итераторов ввода, [i, j) - допустимый диапазон, n - значение X::size_type, p - допустимый итератор для a, q - разыменовываемый итератор для a, [q1, q2) - допустимый диапазон в a, t - значение X::value_type.

Сложности выражений зависят от последовательностей.

Таблица 10. Требования последовательностей (в дополнение к контейнерам)

vector (вектор), list (список) и deque (двусторонняя очередь) выдвигают программисту различные предложения сложности и должны использоваться соответственно. vectоr - тип последовательности, которая используется по умолчанию. list нужно использовать, когда имеются частые вставки и удаления из середины последовательности, deque - структура данных для выбора, когда большинство вставок и удалений происходит в начале или в конце последовательности.

Типы iterator и const_iterator для последовательностей должны быть, по крайней мере, из категории последовательных итераторов.

Таблица 11. Необязательные операции последовательностей

Все операции в расположенной выше таблице обеспечиваются только для контейнеров, для которых они занимают постоянное время.

vector - вид последовательности, которая поддерживает итераторы произвольного доступа. Кроме того, он поддерживает операции вставки и удаления в конце с постоянным (амортизированным) временем; вставка и удаление в середине занимают линейное время. Управление памятью обрабатывается автоматически, хотя для улучшения эффективности можно давать подсказки.

template ‹class T, template ‹class U› class Allocator = allocator›

class vector {

public:

 // определения типов (typedefs):

 typedef iterator;

 typedef const_iterator;

 typedef Allocator‹T›::pointer pointer;

 typedef Allocator‹T›::reference reference;

 typedef Allocator‹T›::const_reference const_reference;

 typedef size_type;

 typedef difference_type;

 typedef T value_type;

 typedef reverse_iterator;

 typedef const_reverse_iterator;

 // размещение/освобождение (allocation/deallocation):

 vector();

 vector(size_type n, const T& value = T());

 vector(const vector‹T, Allocator›& x);

 template ‹class InputIterator›

 vector(InputIterator first, InputIterator last);

 ~vector();

 vector‹T, Allocator›& operator=(const vector‹T, Allocator›& x);

 void reserve(size_type n);

 void swap(vector‹T, Allocator›& x);

 // средства доступа (accessors):

 iterator begin();

 const_iterator begin() const;

 iterator end();

 const_iterator end() const;

 reverse_iterator rbegin();

 const_reverse_iterator rbegin();

 reverse_iterator rend();

 const_reverse_iterator rend();

 size_type size() const;

 size_type max_size() const;

 size_type capacity() const;

 bool empty() const;

 reference operator[](size_type n);

 const_reference operator[](size_type n) const;

 reference front();

 const_reference front() const;

 reference back();

 const_reference back() const;

 // вставка/стирание (insert/irase):

 void push_back(const T& x);

 iterator insert(iterator position, const T& x = T());

 void insert(iterator position, size_type n, const T& x);

 template ‹class InputIterator›

 void insert(iterator position, InputIterator first, InputIterator last);

 void pop_back();

 void erase(iterator position);

 void erase(iterator first, iterator last);

};

template ‹class T, class Allocator›

bool operator==(const vector‹T, Allocator›& x, const vector‹T, Allocator›& y);

template ‹class T, class Allocator›

bool operator‹(const vector‹T, Allocator›& x, const vector‹T, Allocator›& y);

iterator - это итератор произвольного доступа, ссылающийся на T. Точный тип зависит от исполнения и определяется в Allocator.

const_iterator - это постоянный итератор произвольного доступа, ссылающийся на const T. Точный тип зависит от исполнения и определяется в Allocator. Гарантируется, что имеется конструктор для const_iterator из iterator.

size_type - беззнаковый целочисленный тип. Точный тип зависит от исполнения и определяется в Allocator.

difference_type - знаковый целочисленный тип. Точный тип зависит от исполнения и определяется в Allocator.

Конструктор template ‹class InputIterator› vector(InputIterator first, InputIterator last) делает только N вызовов конструктора копирования T (где N - расстояние между first и last) и никаких перераспределений, если итераторы first и last относятся к последовательной, двунаправленной или произвольного доступа категориям. Он делает, самое большее, 2N вызовов конструктора копирования T и logN перераспределений, если они - только итераторы ввода, так как невозможно определить расстояние между first и last и затем сделать копирование.

Функция-член capasity (ёмкость) возвращает размер распределённой памяти в векторе. Функция-член reserve - директива, которая сообщает vector (вектору) запланированноe изменение размера, так чтобы он мог соответственно управлять распределением памяти. Это не изменяет размер последовательности и занимает, самое большее, линейное время от размера последовательности. Перераспределение в этом случае происходит тогда и только тогда, когда текущая ёмкость меньше, чем параметр reserve. После reserve ёмкость (capasity) больше или равна параметру reserve, если происходит перераспределение; а иначе равна предыдущему значению capasity. Перераспределение делает недействительными все ссылки, указатели и итераторы, ссылающиеся на элементы в последовательности. Гарантируется, что нет никакого перераспределения во время вставок, которые происходят после того, как reserve выполняется, до времени, когда размер вектора достигает размера, указанного reserve.

insert (вставка) вызывает перераспределение, если новый размер больше, чем старая ёмкость. Если никакого перераспределения не происходит, все итераторы и ссылки перед точкой вставки остаются справедливыми. Вставка единственного элемента в вектор линейна относительно расстояния от точки вставки до конца вектора. Амортизированная сложность во время жизни вектора, вставляющего единственный элемент в свой конец, постоянна. Вставка множественных элементов в вектор с единственным вызовом вставляющей функции-члена линейна относительно суммы числа элементов плюс расстояние до конца вектора. Другими словами, намного быстрее вставить много элементов в середину вектора сразу, чем делать вставку по одному элементу. Шаблонная вставляющая функция-член предраспределяет достаточно памяти для вставки, если итераторы first и last относятся к последовательной, двунаправленной или произвольного доступа категориям. Иначе функция вставляет элементы один за другим и не должна использоваться для вставки в середину векторов.

erase (стирание) делает недействительными все итераторы и ссылки после пункта стирания. Деструктор T вызывается столько раз, каково число стёртых элементов, а оператор присваивания T вызывается столько раз, каково число элементов в векторе после стёртых элементов.

Чтобы оптимизировать распределение места, даётся определение для bool.

class vector‹bool, allocator› {

public:

 // битовая ссылка (bit reference):

 class reference {

 public:

  ~reference();

  operator bool() const;

  reference& operator=(const bool x);

  void flip(); // инвертирует бит (flips the bit)

 };

 // определения типов (typedefs):

 typedef bool const_reference;

 typedef iterator;

 typedef const_iterator;

 typedef size_t size_type;

 typedef ptrdiff_t difference_type;

 typedef bool value_type;

 typedef reverse_iterator;

 typedef const_reverse_iterator;

 // размещение/освобождение (allocation/deallocation):

 vector();

 vector(size_type n, const bool& value = bool());

 vector(const vector‹bool, allocator›& x);

 template ‹class InputIterator›

 vector(InputIterator first, InputIterator last);

 ~vector();

 vector‹bool, allocator›& operator=(const vector‹bool, allocator›& x);

 void reserve(size_type n);

 void swap(vector‹bool, allocator›& x);

 // средства доступа (accessors):

 iterator begin();

 const_iterator begin() const;

 iterator end();

 const_iterator end() const;

 reverse_iterator rbegin();

 const_reverse_iterator rbegin();

 reverse_iterator rend();

 const_reverse_iterator rend();

 size_type size() const;

 size_type max_size() const;

 size_type capacity() const;

 bool empty() const;

 reference operator[](size_type n);

 const_reference operator[](size_type n) const;

 reference front();

 const_reference front() const;

 reference back();

 const_reference back() const;

 // вставка/стирание (insert/irase):

 void push_back(const bool& x);

 iterator insert(iterator position, const bool& x = bool());

 void insert(iterator position, size_type n, const bool& x);

 template ‹class InputIterator›

 void insert(iterator position, InputIterator first, InputIterator last);

 void pop_back();

 void erase(iterator position);

 void erase(iterator first, iterator last);

};

void swap(vector‹bool, allocator›::reference x, vector‹bool, allocator›::reference y);

bool operator==(const vector‹bool, allocator›& x, const vector‹bool, allocator›& y);

bool operator‹(const vector‹bool, allocator›& x, const vector‹bool, allocator›& y);

reference - класс, который имитирует поведение ссылок отдельного бита в vector‹bool›.

Ожидается, что каждое исполнение обеспечит определение vector‹bool› для всех поддерживаемых моделей памяти.

Сейчас невозможно шаблонизировать определение. То есть мы не можем написать:

template ‹template ‹class U› class Allocator = allocator›

class vector‹bool, Allocator› {/*… */};

Поэтому обеспечивается только vector‹bool, Allocator›.

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

template ‹class T, template ‹class U› class Allocator = allocator›

class list {

public:

 // определения типов:

 typedef iterator;

 typedef const_iterator;

 typedef Allocator‹T›::pointer pointer;

 typedef Allocator‹T›::reference reference;

 typedef Allocator‹T›::const_reference const_reference;

 typedef size_type;

 typedef difference_type;

 typedef Т value_type;

 typedef reverse_iterator;

 typedef const_reverse_iterator;

 // размещение/удаление:

 list()

 list(size_type n, const T& value = T());

 template ‹class InputIterator›

 list(InputIterator first, InputIterator last);

 list(const list‹T, Allocator›& x);

 ~list();

 list‹T, Allocator›& operator=(const list‹T,Allocator›& x);

 void swap(list‹T, Allocator& x);

 // средства доступа:

 iterator begin();

 const_iterator begin() const;

 iterator end();

 const_iterator end() const;

 reverse_iterator rbegin();

 const_reverse_iterator rbegin();

 reverse_iterator rend();

 const_reverse_iterator rend();

 bool empty() const;

 size_type size() const;

 size_type max_size() const;

 reference front();

 const_reference front() const;

 reference back();

 const_reference back() const;

 // вставка/стирание:

 void push_front(const T& x);

 void push_back(const T& x);

 iterator insert(iterator position, const T& x = T());

 void insert(iterator position, size_type n, const T& x);

 template ‹class InputIterator›

 void insert(iterator position, InputIterator first, InputIterator last);

 void pop_front();

 void pop_back();

 void erase(iterator position);

 void erase(iterator first, iterator last);

 // специальные модифицирующие операции cо списком:

 void splice(iterator position, list‹T, Allocator›& x);

 void splice(iterator position, list‹T, Allocator›& x, iterator i);

 void splice(iterator position, list‹T, Allocator›& x, iterator first, iterator last);

 void remove(const T& value);

 template ‹class Predicate›

 void remove_if(Predicate pred);

 void unique();

 template ‹class BinaryPredicate›

 void unique(BinaryPredicate binary_pred);

 void merge(list‹T, Allocator›& x);

 template ‹class Compare›

 void merge(list‹T,Allocator›& x, Compare comp);

 void reverse();

 void sort();

 template ‹class Compare› void sort(Compare comp);

};

template ‹class T, class Allocator›

bool operator==(const list‹T, Allocator›& x, const list‹T, Allocator›& y);

template ‹class T, class Allocator›

bool operator‹(const list‹T, Allocator›& x, const list‹T, Allocator›& y);

iterator - двунаправленный итератор, ссылающийся на T. Точный тип зависит от исполнения и определяется в Allocator.

const_iterator - постоянный двунаправленный итератор, ссылающийся на const T. Точный тип зависит от исполнения и определяется в Allocator. Гарантируется, что имеется конструктор для const_iterator из iterator.

size_type - беззнаковый целочисленный тип. Точный тип зависит от исполнения и определяется в Allocator.

difference_type - знаковый целочисленный тип. Точный тип зависит от исполнения и определяется в Allocator.

insert не влияет на действительность итераторов и ссылок. Вставка единственного элемента в список занимает постоянное время, и ровно один раз вызывается конструктор копирования T. Вставка множественных элементов в список зависит линейно от числа вставленных элементов, а число вызовов конструктора копирования T точно равно числу вставленных элементов.

erase делает недействительными только итераторы и ссылки для стёртых элементов. Стирание единственного элемента - операция постоянного времени с единственным вызовом деструктора T. Стирание диапазона в списке занимает линейное время от размера диапазона, а число вызовов деструктора типа T точно равно размеру диапазона.

Так как списки позволяют быструю вставку и стирание в середине списка, то некоторые операции определяются специально для них:

list обеспечивает три операции стыковки, которые разрушительно перемещают элементы из одного списка в другой:

void splice(iterator position, list‹T, Allocator›& x) вставляет содержимое x перед position, и x становится пустым. Требуется постоянное время. Результат не определён, если &x==this.

void splice(iterator position, list‹T, Allocator›& x, iterator i) вставляет элемент, указываемый i, из списка x перед position и удаляет элемент из x. Требуется постоянное время. i - допустимый разыменовываемый итератор списка x. Результат не изменяется, если position==i или position==++i.

void splice(iterator position, list‹T, Allocator›& x, iterator first, iterator last) вставляет элементы из диапазона [first, last) перед position и удаляет элементы из x. Требуется постоянное время, если &x==this; иначе требуется линейное время. [first, last) - допустимый диапазон в x. Результат не определён, если position - итератор в диапазоне [first, last).

remove стирает все элементы в списке, указанном итератором списка i, для которого выполняются следующие условия: *i==value, pred(*i)==true. remove устойчиво, то есть относительный порядок элементов, которые не удалены, тот же самый, как их относительный порядок в первоначальном списке. Соответствующий предикат применяется точно size() раз.

unique стирает все, кроме первого элемента, из каждой последовательной группы равных элементов в списке. Соответствующий бинарный предикат применяется точно size() - 1 раз.

merge сливает список аргумента со списком (предполагается, что оба сортированы). Слияние устойчиво, то есть для равных элементов в двух списках элементы списка всегда предшествуют элементам из списка аргумента. x пуст после слияния. Выполняется, самое большее, size() + x.size() - 1 сравнений.

reverse переставляет элементы в списке в обратном порядке. Операция линейного времени.

sort сортирует список согласно operator‹ или сравнивающему функциональному объекту. Она устойчива, то есть относительный порядок равных элементов сохраняется. Выполняется приблизительно NlogN сравнений, где N равно size().

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

template ‹class T, template ‹class U› class Allocator = allocator›

class deque {

public:

 // typedefs:

 typedef iterator;

 typedef const_iterator;

 typedef Allocator‹T›::pointer pointer;

 typedef Allocator‹T›::reference reference;

 typedef Allocator‹T›::const_reference const_reference;

 typedef size_type;

 typedef difference_type;

 typedef Т value_type;

 typedef reverse_iterator;

 typedef const_revcrse_iterator;

 // размещение/удаление:

 deque();

 deque(size_type n, const T& value = T());

 deque(const deque‹T, Allocator›& x);

 template ‹class InputIterator›

 deque(InputIterator first, InputIterator last);

 ~deque();

 deque‹T, Allocator›& operator=(const deque‹T,Allocator›& x);

 void swap(deque‹T, Allocator›& x);

 // средства доступа:

 iterator begin();

 const_iterator begin() const;

 iterator end();

 const_iterator end() const;

 reverse_iterator rbegin();

 const_reverse_iterator rbegin();

 reverse_iterator rend();

 const_reverse_iterator rend();

 size_type size() const;

 size_type max_size() const;

 bool empty() const;

 reference operator[](size_type n);

 const_reference operator[](size_type n) const;

 reference front();

 const_reference front() const;

 reference back();

 const_reference back() const;

 // вставка/стирание:

 void push_front(const T& x);

 void push_back(const T& x);

 iterator insert(iterator position, const T& x = T());

 void insert(iterator position, size_type n, const T& x);

 template

 void insert(iterator position, InputIterator first, InputIterator last);

 void pop_front();

 void pop_back();

 void erase(iterator position);

 void erase(iterator first, iterator last);

};

template ‹class T, class Allocator›

bool operator==(const deque‹T, Allocator›& x, const deque‹T, Allocator›& y);

template ‹class T, class Allocator›

bool operator‹(const deque‹T, Allocator›& x, const deque‹T, Allocator›& y);

iterator - итератор произвольного доступа, ссылающийся на T. Точный тип зависит от исполнения и определяется в Allocator.

const_iterator - постоянный итератор произвольного доступа, ссылающийся на const T. Точный тип зависит от исполнения и определяется в Allocator. Гарантируется, что имеется конструктор для const_iterator из iterator.

size_type - беззнаковый целочисленный тип. Точный тип зависит от исполнения и определяется в Allocator.

difference_type - знаковый целочисленный тип. Точный зависит от исполнения и определяется в Allocator.

insert (вставка) в середину двусторонней очереди делает недействительными все итераторы и ссылки двусторонней очереди. insert и push (помещение) с обоих концов двусторонней очереди делают недействительными все итераторы двусторонней очереди, но не влияют на действительность всех ссылок на двустороннюю очередь. В худшем случае вставка единственного элемента в двустороннюю очередь занимает линейное время от минимума двух расстояний: от точки вставки - до начала и до конца двусторонней очереди. Вставка единственного элемента либо в начало, либо в конец двусторонней очереди всегда занимает постоянное время и вызывает единственный запрос конструктора копии T. То есть двусторонняя очередь особенно оптимизирована для помещения и извлечения элементов в начале и в конце.

erase (стирание) в середине двусторонней очереди делает недействительными все итераторы и ссылки двусторонней очереди. erase и pop (извлечение) с обоих концов двусторонней очереди делают недействительными только итераторы и ссылки на стёртый элемент. Число вызовов деструктора равно числу стёртых элементов, а число вызовов оператора присваивания равно минимуму из числа элементов перед стёртыми элементами и числа элементов после стёртых элементов.

Ассоциативные контейнеры обеспечивают быстрый поиск данных, основанных на ключах. Библиотека предоставляет четыре основных вида ассоциативных контейнеров: set (множество), multiset (множество с дубликатами), map (словарь) и multimap (словарь с дубликатами).

Все они берут в качестве параметров Key (ключ) и упорядочивающее отношение Compare, которое вызывает полное упорядочение по элементам Key. Кроме того, map и multimap ассоциируют произвольный тип T с Key. Объект типа Compare называется сравнивающим объектом (comparison object) контейнера.

В этом разделе, когда мы говорим о равенстве ключей, мы подразумеваем отношение эквивалентности, обусловленное сравнением и не (not) operator== для ключей. То есть считается, что два ключа k1 и k2 являются равными, если для сравнивающего объекта comp истинно comp(k1, k2)==false && comp(k2, k1)==false.

Ассоциативный контейнер поддерживает уникальные ключи (unique keys), если он может содержать, самое большее, один элемент для каждого значения ключа. Иначе он поддерживает равные ключи (equal keys). set и map поддерживают уникальные ключи. multiset и multimap поддерживают равные ключи.

Для set и multiset значимый тип - тот же самый, что и тип ключа. Для map и multimap он равен pair‹const Key, T›.

iterator ассоциативного контейнера относится к категории двунаправленного итератора. insert не влияет на действительность итераторов и ссылок контейнера, а erase делает недействительными только итераторы и ссылки на стёртые элементы.

В следующей таблице обозначается: X - класс ассоциативного контейнера, a - значение X, a_uniq - значение X, когда X поддерживает уникальные ключи, a a_eq - значение X, когда X поддерживает многократные ключи, i и j удовлетворяют требованиям итераторов ввода и указывают на элементы value_type, [i, j) - допустимый диапазон, p - допустимый итератор для a, q - разыменовываемый итератор для a, [q1, q2) - допустимый диапазон в a, t - значение X::value_type и k - значение X::key_type.

Таблица 12. Требования ассоциативных контейнеров (в дополнение к контейнерам)

Основным свойством итераторов ассоциативных контейнеров является то, что они выполняют итерации через контейнеры в порядке неубывания ключей, где неубывание определено сравнением, которое использовалось для их создания. Для любых двух разыменованных итераторов i и j таких, что расстояние от i до j является положительным, value_comp (*j, *i)==false. Для ассоциативных контейнеров с уникальными ключами выдерживается более сильное условие value_comp(*i, *j)==true.

set - это ассоциативный контейнер, который поддерживает уникальные ключи (не содержит ключи с одинаковыми значениями) и обеспечивает быстрый поиск ключей.

template ‹class Key, class Compare = less‹Key›, template ‹class U› class Allocator = allocator›

class set {

public:

 // typedefs:

 typedef Key key_type;

 typedef Key value_type;

 typedef Allocator‹Key›::pointer pointer;

 typedef Allocator‹Key›::reference reference;

 typedef Allocator‹Key›::const_reference const_reference;

 typedef Compare key_compare;

 typedef Compare value_compare;

 typedef iterator;

 typedef iterator const_iterator;

 typedef size_type;

 typedef difference_type;

 typedef reverse_iterator;

 typedef const_reverse_iterator;

 // allocation/deallocation:

 set(const Compare& comp = Compare());

 template ‹class InputIterator›

 set(InputIterator first, InputIterator last, const Compare& comp = Compare());

 set(const set‹Key, Compare, Allocator›& x);

 ~set();

 set‹Key, Compare, Allocator›& operator=(const set‹Key, Compare, Allocator›& x);

 void swap(set‹Key, Compare, Allocator›& x);

 // accessors:

 key_compare key_comp() const;

 value_compare value_comp() const;

 iterator begin() const;

 iterator end() const;

 reverse_iterator rbegin() const;

 reverse_iterator rend() const;

 bool empty() const;

 size_type size() const;

 size_type max_size() const;

 // insert/erase

 pair‹iterator, bool› insert(const value_type& x);

 iterator insert(iterator position, const value_type& x);

 template ‹class InputIterator›

 void insert(InputIterator first, InputIterator last);

 void erase(iterator position);

 size_type erase(const key_type& x);

 void erase(iterator first, iterator last);

 // set operations:

 iterator find(const key_type& x) const;

 size_type count(const key_type& x) const;

 iterator lower_bound(const key_type& x) const;

 iterator upper_bound(const key_type& x) const;

 pair‹iterator, iterator› equal_range(const key_type& x) const;

};

template ‹class Key, class Compare, class Allocator›

bool operator==(const set‹Key, Compare, Allocator›& x, const set‹Key, Compare, Allocator›& y);

template ‹class Key, class Compare, class Allocator›

bool operator‹(const set‹Key, Compare, Allocator›& x, const set‹Key, Compare, Allocator›& y);

iterator - постоянный двунаправленный итератор, указывающий на const value_type. Точный тип зависит от реализации и определяется в Allocator.

сonst_iterator - тот же самый тип, что и iterator.

size_type - целочисленный тип без знака. Точный тип зависит от реализации и определяется в Allocator.

difference_type - целочисленный тип со знаком. Точный тип зависит от реализации и определяется в Allocator.

multiset - это ассоциативный контейнер, который поддерживает равные ключи (возможно, содержит множественные копии того же самого значения ключа) и обеспечивает быстрый поиск ключей.

template ‹class Key, class Compare = less‹Key›, template ‹class U› class Allocator = allocator›

class multiset {

public:

 // typedefs:

 typedef Key key_type;

 typedef Key value_type;

 typedef Allocator‹Key›::pointer pointer;

 typedef Aliocator‹Key›::reference reference;

 typedef Allocator‹Key›::const_reference const_reference;

 typedef Compare key_compare;

 typedef Compare value_compare;

 typedef iterator;

 typedef iterator const_iterator;

 typedef size_type;

 typedef difference_type;

 typedef reverse_iterator;

 typedef const_reverse_iterator;

 // allocation/deallocation:

 multiset(const Compare& comp = Compare());

 template ‹class InputIterator›

 multiset(InputIterator first, InputIterator last, const Compare& comp = Compare());

 multiset(const multiset‹Key, Compare, Allocator›& x);

 ~multiset();

 multiset‹Key, Compare, Allocator›& operator=(const multiset‹Key, Compare, Allocator›& x);

 void swap(multiset‹Key, Compare, Allocator›& x);

 // accessors:

 key_compare key_comp() const;

 value_compare value_comp() const;

 iterator begin() const;

 iterator end() const;

 reverse_iterator rbegin();

 reverse_iterator rend();

 bool empty() const;

 size_type size() const;

 size_type max_size() const;

 // insert/erase:

 iterator insert(const value_type& x);

 iterator insert(iterator position, const value_type& x);

 template ‹class InputIterator›

 void insert(InputIterator first, InputIterator last);

 void erase(iterator position);

 size_type erase(const key_type& x);

 void erase(iterator first, iterator last);

 // multiset operations:

 iterator find(const key_type& x) const;

 size_type count(const key_type& x) const;

 iterator lower_bound(const key_type& x) const;

 iterator upper_bound(const key_type& x) const;

 pair‹iterator, iterator› equal_range(const key_type& x) const;

};

template ‹class Key, class Compare, class Allocator›

bool operator==(const multiset‹Key, Compare, Allocator›& x, const multiset‹Key, Compare, Allocator›& y);

template ‹class Key, class Compare, class Allocator›

bool operator‹(const multiset‹Key, Compare, Allocator›& x, const multiset‹Key, Compare, Allocator›& y);

iterator - постоянный двунаправленный итератор, указывающий на const value_type. Точный тип зависит от реализации и определяется в Allocator.

сonst_iterator - тот же самый тип, что и iterator.

size_type - целочисленный тип без знака. Точный тип зависит от реализации и определяется в Allocator.

difference_type - целочисленный тип со знаком. Точный тип зависит от реализации и определяется в Allocator.

map - ассоциативный контейнер, который поддерживает уникальные ключи (не содержит ключи с одинаковыми значениями) и обеспечивает быстрый поиск значений другого типа T, связанных с ключами.

template ‹class Key, class T, class Compare = less‹Key›, template ‹class U› class Allocator = allocator›

class map {

public:

 // typedefs:

 typedef Key key_type;

 typedef pair‹const Key, T› value_type;

 typedef Compare key_compare;

 class value_compare : public binary_function‹value_type, value_type, bool› {

  friend class map;

 protected:

  Compare comp;

  value_compare(Compare c): comp(c) {}

 public:

  bool operator()(const value_type& x, const value_type& y) {

   return comp(x.first, y.first);

  }

 };

 typedef iterator;

 typedef const_iterator;

 typedef Allocator‹value_type›::pointer pointer;

 typedef Allocator‹value_type›::reference reference;

 typedef Allocator‹value_type›::const_reference const_reference;

 typedef size_type;

 typedef difference_type;

 typedef reverse_iterator;

 typedef const_reverse_iterator;

 // allocation/deallocation:

 map(const Compare& comp = Compare());

 template ‹class InputIterator›

 map(InputIterator first, InputIterator last, const Compare& comp = Compare());

 map(const map‹Key, T, Compare, Allocator›& x);

 ~map();

 map‹Key, T, Compare, Allocator›& operator=(const map‹Key, T, Compare, Allocator›& x);

 void swap(map‹Key, T, Compare, Allocator›& x);

 // accessors:

 key_compare key_comp() const;

 value_compare value_comp() const;

 iterator begin();

 const_iterator begin() const;

 iterator end();

 const_iterator end() const;

 reverse_iterator rbegin();

 const_reverse_iterator rbegin();

 reverse_iterator rend();

 const_reverse_iterator rend();

 bool empty() const;

 size_type size() const;

 size_type max_size() const;

 Allocator‹T›::reference operator[](const key_type& x);

 // insert/erase:

 pair‹iterator, bool› insert(const value_type& x);

 iterator insert(iterator position, const value_type& x);

 template ‹class InputIterator›

 void insert(InputIterator first, InputIterator last);

 void erase(iterator position);

 size_type erase(const key_type& x);

 void erase(iterator first, iterator last);

 // map operations:

 iterator find(const key_type& x);

 const_iterator find(const key_type& x) const;

 size_type count(const key_type& x) const;

 iterator lower_bound(const key_type& x);

 const_iterator lower_bound(const key_type& x) const;

 iterator upper_bound(const key_type& x);

 const_iterator upper_bound(const key_type& x) const;

 pair‹iterator, iterator› equal_range(const key_type& x);

 pair‹const_iterator, const_iterator› equal_range(const key_type& x)const;

};

template ‹class Key, class T, class Compare, class Allocator›

bool operator==(const map‹Key, T, Compare, Allocator›& x, const map‹Key, T, Compare, Allocator›& y);

template ‹class Key, class T, class Compare, class Allocator›

bool operator‹(const map‹Key, T, Compare, Allocator›& x, const map‹Key, T, Compare, Allocator›& y);

iterator - двунаправленный итератор, указывающий на value_type. Точный тип зависит от реализации и определяется в Allocator.

const_iterator - постоянный двунаправленный итератор, указывающий на const value_type. Точный тип зависит от реализации и определяется в Allocator. Гарантируется, что имеется конструктор для const_iterator из iterator.

size_type - целочисленный тип без знака. Точный тип зависит от реализации и определяется в Allocator.

difference_type - целочисленный тип со знаком. Точный тип зависит от реализации и определяется в Allocator.

В дополнение к стандартному набору методов ассоциативных контейнеров, map обеспечивает операцию Allocator::reference operator[](const key_type&). Для словаря m и ключа k запись m[k] семантически эквивалентна (*((m.insert(make_pair(k, T()))).first)).second.

multimар - ассоциативный контейнер, который поддерживает равные ключи (возможно, содержит множественные копии того же самого значения ключа) и обеспечивает быстрый поиск значений другого типа T, связанных с ключами.

template ‹class Key, class T, class Compare = less‹Key›, template ‹class U› class Allocator = allocator›

class multimap {

public:

 // typedefs:

 typedef Key key_type;

 typedef pair‹const Key, T› value_type;

 typedef Compare key_compare;

 class value_compare : public binary_function‹value_type, value_type, bool› {

  friend class multimap;

 protected:

  Compare comp;

  value_compare(Compare c): comp(c) {}

 public:

  bool operator()(const value_type& x, const value_type& y) {

   return comp(x.first, y.first);

  }

 };

 typedef iterator;

 typedef const_iterator;

 typedef Allocator‹value_type›::pointer pointer;

 typedef Allocator‹value_type›::reference reference;

 typedef Allocator‹value_type›::const_reference const_reference;

 typedef size_type;

 typedef difference_type;

 typedef reverse_iterator;

 typedef const_reverse_iterator;

 // allocation/deallocation:

 multimap(const Compare& comp = Compare());

 template ‹class InputIterator›

 multimap(InputIterator first, InputIterator last, const Compare& comp = Compare());

 multimap(const multimap‹Key, T, Compare, Allocator›& x);

 ~multimap();

 multimap‹Key, T, Compare, Allocator›& operator=(const multimap‹Key, T, Compare, Allocator›& x);

 void swap(multimap‹Key, T, Compare, Allocator›& x);

 // accessors:

 key_compare key_comp() const;

 value_compare value_comp() const;

 iterator begin();

 const_iterator begin() const;

 iterator end();

 const_iterator end() const;

 reverse_iterator rbegin();

 const_reverse_iterator rbegin();

 reverse_iterator rend()

 const_reverse_iterator rend();

 bool empty() const;

 size_type size() const;

 size_type max_size() const;

 // insert/erase:

 iterator insert(const value_type& x);

 iterator insert(iterator position, const value_type& x);

 template ‹class InputIterator›

 void insert(InputIterator first, InputIterator last);

 void erase(iterator position);

 size_type erase(const key_type& x);

 void erase(iterator first, iterator last);

 // multimap operations:

 iterator find(const key_type& x);

 const_iterator find(const key_type& x) const;

 size_type count(const key_type& x) const;

 iterator lower_bound(const key_type& x);

 const_iterator lower_bound(const key_type& x) const;

 iterator upper_bound(const key_type& x);

 const_iterator upper_bound(const key_type& x) const;

 pair‹iterator, iterator› equal_range(const key_type& x);

 pair‹const_iterator, const_iterator› equal_range(const key_type& x) const;

};

template ‹class Key, class T, class Compare, class Allocator›

bool operator==(const multimap‹Key, T, Compare, Allocator›& x, const multimap‹Key, T, Compare, Allocator›& y);

template ‹class Key, class T, class Compare, class Allocator›

bool operator‹(const multimap‹Key, T, Compare, Allocator›& x, const multimap‹Key, T, Compare, Allocator›& y);

iterator - двунаправленный итератор, указывающий на value_type. Точный тип зависит от реализации и определяется в Allocator.

const_iterator - постоянный двунаправленный итератор, указывающий на value_type. Точный тип зависит от реализации и определяется в Allocator. Гарантируется, что имеется конструктор для const_iterator из iterator.

size_type - целочисленный тип без знака. Точный тип зависит от реализации и определяется в Allocator.

difference_type - целочисленный тип со знаком. Точный тип зависит от реализации и определяется в Allocator.