Spec-Zone.ru › C++

std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::flat_map

flat_map()
    : flat_map(key_compare()) { }
(1) (начиная с C++23) 
template< class Allocator >
flat_map( const flat_map&, const Allocator& alloc );
(2) (начиная с C++23) 
template< class Allocator >
flat_map( flat_map&&, const Allocator& alloc );
(3) (начиная с C++23) 
flat_map( key_container_type key_cont, mapped_container_type mapped_cont,
          const key_compare& comp = key_compare() );
(4) (начиная с C++23) 
template< class Allocator >
flat_map( const key_container_type& key_cont,
          const mapped_container_type& mapped_cont,
          const Allocator& alloc );
(5) (начиная с C++23) 
template< class Allocator >
flat_map( const key_container_type& key_cont,
          const mapped_container_type& mapped_cont,
          const key_compare& comp, const Allocator& alloc );
(6) (начиная с C++23) 
flat_map( std::sorted_unique_t, key_container_type key_cont,
          mapped_container_type mapped_cont,
          const key_compare& comp = key_compare() );
(7) (начиная с C++23) 
template< class Allocator >
flat_map( std::sorted_unique_t, const key_container_type& key_cont,
          const mapped_container_type& mapped_cont, const Allocator& alloc );
(8) (начиная с C++23) 
template< class Allocator >
flat_map( std::sorted_unique_t, const key_container_type& key_cont,
          const mapped_container_type& mapped_cont,
          const key_compare& comp, const Allocator& alloc );
(9) (начиная с C++23) 
explicit flat_map( const key_compare& comp )
    : c(), compare(comp) { }
(10) (начиная с C++23) 
template< class Allocator >
flat_map( const key_compare& comp, const Allocator& alloc );
(11) (начиная с C++23) 
template< class Allocator >
explicit flat_map( const Allocator& alloc );
(12) (начиная с C++23) 
template< class InputIter >
flat_map( InputIter first, InputIter last,
          const key_compare& comp = key_compare() )
    : c(), compare(comp);
(13) (начиная с C++23) 
template< class InputIter, class Allocator >
flat_map( InputIter first, InputIter last,
          const key_compare& comp, const Allocator& alloc );
(14) (начиная с C++23) 
template< class InputIter, class Allocator >
flat_map( InputIter first, InputIter last, const Allocator& alloc );
(15) (начиная с C++23) 
template< container-compatible-range<value_type> R >
flat_map( std::from_range_t, R&& rg, const key_compare& comp )
    : flat_map(comp);
(16) (начиная с C++23) 
template< container-compatible-range<value_type> R >
flat_map( std::from_range_t fr, R&& rg )
    : flat_map(fr, std::forward<R>(rg), key_compare()) { }
(17) (начиная с C++23) 
template< container-compatible-range<value_type> R, class Allocator >
flat_map( std::from_range_t, R&& rg, const Allocator& alloc );
(18) (начиная с C++23) 
template< container-compatible-range<value_type> R, class Allocator >
flat_map( std::from_range_t, R&& rg, const key_compare& comp,
          const Allocator& alloc );
(19) (начиная с C++23) 
template< class InputIter >
flat_map( std::sorted_unique_t s, InputIter first, InputIter last,
          const key_compare& comp = key_compare() )
    : c(), compare(comp);
(20) (начиная с C++23) 
template< class InputIter, class Allocator >
flat_map( std::sorted_unique_t s, InputIter first, InputIter last,
          const key_compare& comp, const Allocator& alloc );
(21) (начиная с C++23) 
template< class InputIter, class Allocator >
flat_map( std::sorted_unique_t s, InputIter first, InputIter last,
          const Allocator& alloc );
(22) (начиная с C++23) 
flat_map( std::initializer_list<value_type> init,
          const key_compare& comp = key_compare() )
    : flat_map(init.begin(), init.end(), comp) { }
(23) (начиная с C++23) 
template< class Allocator >
flat_map( std::initializer_list<value_type> init, const key_compare& comp,
          const Allocator& alloc );
(24) (начиная с C++23) 
template< class Allocator >
flat_map( std::initializer_list<value_type> init, const Allocator& alloc );
(25) (начиная с C++23) 
flat_map( std::sorted_unique_t s, std::initializer_list<value_type> init,
          const key_compare& comp = key_compare() )
    : flat_map(s, init.begin(), init.end(), comp) { }
(26) (начиная с C++23) 
template< class Allocator >
flat_map( std::sorted_unique_t s, std::initializer_list<value_type> init,
          const key_compare& comp, const Allocator& alloc );
(27) (начиная с C++23) 
template< class Allocator >
flat_map( std::sorted_unique_t s, std::initializer_list<value_type> init,
          const Allocator& alloc );
(28) (начиная с C++23)

Создаёт новый адаптер контейнера из различных источников данных и, при необходимости, использует предоставленный пользователем объект-функцию сравнения comp и/или распределитель памяти alloc.

1) Конструктор по умолчанию. Создаёт пустой адаптер контейнера.
2) Конструктор копирования. Создаёт c с копией содержимого other.c, а compare — со значением other.compare. См. примечание об использовании распределителя памяти ниже.
3) Конструктор перемещения. Создаёт адаптер контейнера с содержимым other, используя семантику перемещения. См. примечание об использовании распределителя памяти ниже.
4) Сначала инициализирует c.keys значением std::move(key_cont), c.values значением std::move(mapped_cont), а compare — значением comp. Затем сортирует базовый диапазон [begin(), end()) относительно value_comp(). Наконец, удаляет повторяющиеся элементы, как если бы выполнялось:
auto zv = views::zip(c.keys, c.values);auto it = ranges::unique(zv, key_equiv(compare)).begin();auto dist = distance(zv.begin(), it);c.keys.erase(c.keys.begin() + dist, c.keys.end());c.values.erase(c.values.begin() + dist, c.values.end());.
5) То же, что (4), эквивалентно flat_map(key_cont, mapped_cont);. См. примечание об использовании распределителя памяти ниже.
6) То же, что (4), эквивалентно flat_map(key_cont, mapped_cont, comp);. См. примечание об использовании распределителя памяти ниже.
7) Инициализирует c.keys значением std::move(key_cont), c.values значением std::move(mapped_cont), а compare — значением comp.
8) То же, что (7), эквивалентно flat_map(s, key_cont, mapped_cont);. См. примечание об использовании распределителя памяти ниже.
9) То же, что (7), эквивалентно flat_map(s, key_cont, mapped_cont, comp);. См. примечание об использовании распределителя памяти ниже.
10) Создаёт пустой адаптер контейнера.
11,12) Создаёт пустой адаптер контейнера. См. примечание об использовании распределителя памяти ниже.
13) Создаёт адаптер контейнера с содержимым диапазона [first, last), эквивалентно insert(first, last);.
14,15) То же, что (13). См. примечание об использовании распределителя памяти ниже.
16) Создаёт адаптер контейнера с содержимым диапазона rg. Сначала использует (10) как делегирующий конструктор. Затем инициализирует c содержимым rg, как если бы выполнялось insert_range(std::forward<R>(rg));.
17) То же, что (16), используя его как делегирующий конструктор.
18,19) То же, что (16). См. примечание об использовании распределителя памяти ниже.
20) Создаёт базовые контейнеры с содержимым диапазона [first, last), как если бы выполнялось insert(first, last).
21,22) То же, что (20). См. примечание об использовании распределителя памяти ниже.
23) Конструктор со списком инициализации. Создаёт базовый контейнер с содержимым списка инициализации init, используя (13) как делегирующий конструктор.
24,25) То же, что (23). См. примечание об использовании распределителя памяти ниже.
26) Конструктор со списком инициализации. Создаёт базовый контейнер с содержимым списка инициализации init, используя (20) как делегирующий конструктор.
27,28) То же, что (26). См. примечание об использовании распределителя памяти ниже.

Примечание для перегрузок (13-15,20-22): если [first, last) не является допустимым диапазоном, поведение не определено.

Примечание для перегрузок (4-6,13-19,23-25): если несколько элементов диапазона имеют ключи, эквивалентные при сравнении, не указано, какой из элементов будет вставлен (ожидает рассмотрения в LWG2844).

Примечание об использовании распределителя памяти

Конструкторы (2,3,5,6,8,9,11,12,14,15,17,19,21,22,24,25,27,28) эквивалентны соответствующим конструкторам без распределителя памяти, за исключением того, что базовые контейнеры c.keys и c.values создаются с использованием конструирования с использованием распределителя памяти. Эти перегрузки участвуют в разрешении перегрузки, только если std::uses_allocator_v<container_type, Allocator> является true.

Параметры

key_cont - контейнер, используемый в качестве источника для инициализации базового контейнера ключей
mapped_cont - контейнер, используемый в качестве источника для инициализации базового контейнера значений
other - другой flat_map, используемый как источник для инициализации элементов базовых контейнеров
alloc - распределитель памяти, используемый для всех выделений памяти базовыми контейнерами
comp - объект-функция, используемый для всех сравнений ключей
first, last - пара итераторов, задающая исходный диапазон копируемых элементов
init - список инициализации для задания элементов базовых контейнеров
rg - диапазон, совместимый с контейнером (то есть input_range, элементы которого можно преобразовать в value_type), используемый как источник для инициализации базовых контейнеров
fr - тег для устранения неоднозначности, указывающий, что содержащийся член должен быть сконструирован из диапазона
s - тег для устранения неоднозначности, указывающий, что входная последовательность отсортирована относительно value_comp() и все её элементы уникальны
Требования к типам
-InputIt должен соответствовать требованиям LegacyInputIterator.
-Compare должен соответствовать требованиям Compare.
-Allocator должен соответствовать требованиям Allocator.

Сложность

1) Постоянная.
2) Линейная относительно размера other.
3) Такая же, как у соответствующего конструктора перемещения обёрнутого контейнера, то есть постоянная или линейная относительно размера cont.
4-6) Линейная по \(\scriptsize N\)N, если cont отсортирован относительно value_comp(); в противном случае \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N)), где \(\scriptsize N\)N — значение key_cont.size() до этого вызова.
7-9) Такая же, как у соответствующего конструктора перемещения обёрнутого контейнера, то есть постоянная или линейная относительно размера cont.
10-12) Постоянная.
13-15) Линейная по \(\scriptsize N\)N, если входной диапазон [first, last) отсортирован относительно value_comp(); в противном случае \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N)), где \(\scriptsize N\)N — значение key_cont.size() до этого вызова.
16-19) Линейная по \(\scriptsize N\)N, если входной диапазон rg отсортирован относительно value_comp(); в противном случае \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N)), где \(\scriptsize N\)N — значение key_cont.size() до этого вызова.
20-22) Линейная относительно размера [first, last).
23-25) Линейная по \(\scriptsize N\)N, если элементы init отсортированы относительно value_comp(); в противном случае \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·log(N)), где \(\scriptsize N\)N — значение key_cont.size() до этого вызова.
26-28) Линейная относительно размера init.

Исключения

Вызовы Allocator::allocate могут выбрасывать исключения.

Примечания

После перемещающего конструирования контейнера (перегрузка (3)) ссылки, указатели и итераторы, которые изначально ссылались на элементы в other, остаются действительными, но теперь ссылаются на элементы в *this. В текущем стандарте эта гарантия обеспечивается общим утверждением в [container.reqmts]/67; также рассматривается возможность более прямой гарантии посредством проблемы LWG 2321.

Пример

См. также

operator=
 присваивает значения адаптеру контейнера
(открытая функция-член)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/container/flat_map/flat_map

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API