Class template flat_map . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Boost.Container Header Reference

Class template flat_map

boost::container::flat_map

Synopsis

// In header: <boost/container/flat_map.hpp>
template<typename Key, typename T, typename Compare = std::less<Key>, 
         typename Allocator = new_allocator< std::pair< Key, T> > > 
class flat_map {
public:
  // types
  typedef Key                                                              key_type;              
  typedef T                                                                mapped_type;           
  typedef std::pair< Key, T >                                              value_type;            
  typedef ::boost::container::allocator_traits< Allocator >                allocator_traits_type; 
  typedef boost::container::allocator_traits< Allocator >::pointer         pointer;               
  typedef boost::container::allocator_traits< Allocator >::const_pointer   const_pointer;         
  typedef boost::container::allocator_traits< Allocator >::reference       reference;             
  typedef boost::container::allocator_traits< Allocator >::const_reference const_reference;       
  typedef boost::container::allocator_traits< Allocator >::size_type       size_type;             
  typedef boost::container::allocator_traits< Allocator >::difference_type difference_type;       
  typedef Allocator                                                        allocator_type;        
  typedef implementation_defined                                           stored_allocator_type; 
  typedef implementation_defined                                           value_compare;         
  typedef Compare                                                          key_compare;           
  typedef implementation_defined                                           iterator;              
  typedef implementation_defined                                           const_iterator;        
  typedef implementation_defined                                           reverse_iterator;      
  typedef implementation_defined                                           const_reverse_iterator;
  typedef implementation_defined                                           movable_value_type;    
  // construct/copy/destruct
  flat_map() noexcept(container_detail::is_nothrow_default_constructible< Allocator >::value &&container_detail::is_nothrow_default_constructible< Compare >::value));
  explicit flat_map(const Compare &, 
                    const allocator_type & = allocator_type());
  explicit flat_map(const allocator_type &);
  template<typename InputIterator> 
    flat_map(InputIterator, InputIterator, const Compare & = Compare(), 
             const allocator_type & = allocator_type());
  template<typename InputIterator> 
    flat_map(InputIterator, InputIterator, const allocator_type &);
  template<typename InputIterator> 
    flat_map(ordered_unique_range_t, InputIterator, InputIterator, 
             const Compare & = Compare(), 
             const allocator_type & = allocator_type());
  flat_map(std::initializer_list< value_type >, const Compare & = Compare(), 
           const allocator_type & = allocator_type());
  flat_map(std::initializer_list< value_type >, const allocator_type &);
  flat_map(ordered_unique_range_t, std::initializer_list< value_type >, 
           const Compare & = Compare(), 
           const allocator_type & = allocator_type());
  flat_map(const flat_map &);
  flat_map(flat_map &&) noexcept(boost::container::container_detail::is_nothrow_move_constructible< Compare >::value));
  flat_map(const flat_map &, const allocator_type &);
  flat_map(flat_map &&, const allocator_type &);
  flat_map & operator=(const flat_map &);
  flat_map & operator=(flat_map &&) noexcept((allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value)&&boost::container::container_detail::is_nothrow_move_assignable< Compare >::value));
  flat_map & operator=(std::initializer_list< value_type >);
  // public member functions
  allocator_type get_allocator() const noexcept;
  stored_allocator_type & get_stored_allocator() noexcept;
  const stored_allocator_type & get_stored_allocator() const noexcept;
  iterator begin() noexcept;
  const_iterator begin() const noexcept;
  iterator end() noexcept;
  const_iterator end() const noexcept;
  reverse_iterator rbegin() noexcept;
  const_reverse_iterator rbegin() const noexcept;
  reverse_iterator rend() noexcept;
  const_reverse_iterator rend() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;
  const_reverse_iterator crbegin() const noexcept;
  const_reverse_iterator crend() const noexcept;
  bool empty() const noexcept;
  size_type size() const noexcept;
  size_type max_size() const noexcept;
  size_type capacity() const noexcept;
  void reserve(size_type);
  void shrink_to_fit();
  mapped_type & operator[](const key_type &);
  mapped_type & operator[](key_type &&);
  template<typename M> 
    std::pair< iterator, bool > insert_or_assign(const key_type &, M &&);
  template<typename M> 
    std::pair< iterator, bool > insert_or_assign(key_type &&, M &&);
  template<typename M> 
    iterator insert_or_assign(const_iterator, const key_type &, M &&);
  template<typename M> 
    iterator insert_or_assign(const_iterator, key_type &&, M &&);
  iterator nth(size_type) noexcept;
  const_iterator nth(size_type) const noexcept;
  size_type index_of(iterator) noexcept;
  size_type index_of(const_iterator) const noexcept;
  T & at(const key_type &);
  const T & at(const key_type &) const;
  template<class... Args> std::pair< iterator, bool > emplace(Args &&...);
  template<class... Args> iterator emplace_hint(const_iterator, Args &&...);
  template<class... Args> 
    std::pair< iterator, bool > try_emplace(const key_type &, Args &&...);
  template<class... Args> 
    iterator try_emplace(const_iterator, const key_type &, Args &&...);
  template<class... Args> 
    std::pair< iterator, bool > try_emplace(key_type &&, Args &&...);
  template<class... Args> 
    iterator try_emplace(const_iterator, key_type &&, Args &&...);
  std::pair< iterator, bool > insert(const value_type &);
  std::pair< iterator, bool > insert(value_type &&);
  std::pair< iterator, bool > insert(movable_value_type &&);
  iterator insert(const_iterator, const value_type &);
  iterator insert(const_iterator, value_type &&);
  iterator insert(const_iterator, movable_value_type &&);
  template<typename InputIterator> void insert(InputIterator, InputIterator);
  template<typename InputIterator> 
    void insert(ordered_unique_range_t, InputIterator, InputIterator);
  void insert(std::initializer_list< value_type >);
  void insert(ordered_unique_range_t, std::initializer_list< value_type >);
  template<typename C2> void merge(flat_map< Key, T, C2, Allocator > &);
  template<typename C2> void merge(flat_map< Key, T, C2, Allocator > &&);
  template<typename C2> void merge(flat_multimap< Key, T, C2, Allocator > &);
  template<typename C2> void merge(flat_multimap< Key, T, C2, Allocator > &&);
  iterator erase(const_iterator);
  size_type erase(const key_type &);
  iterator erase(const_iterator, const_iterator);
  void swap(flat_map &) noexcept(allocator_traits_type::is_always_equal::value &&boost::container::container_detail::is_nothrow_swappable< Compare >::value));
  void clear() noexcept;
  key_compare key_comp() const;
  value_compare value_comp() const;
  iterator find(const key_type &);
  const_iterator find(const key_type &) const;
  size_type count(const key_type &) const;
  iterator lower_bound(const key_type &);
  const_iterator lower_bound(const key_type &) const;
  iterator upper_bound(const key_type &);
  const_iterator upper_bound(const key_type &) const;
  std::pair< iterator, iterator > equal_range(const key_type &);
  std::pair< const_iterator, const_iterator > 
  equal_range(const key_type &) const;
  // friend functions
  friend bool operator==(const flat_map &, const flat_map &);
  friend bool operator!=(const flat_map &, const flat_map &);
  friend bool operator<(const flat_map &, const flat_map &);
  friend bool operator>(const flat_map &, const flat_map &);
  friend bool operator<=(const flat_map &, const flat_map &);
  friend bool operator>=(const flat_map &, const flat_map &);
  friend void swap(flat_map &, flat_map &);
};

Description

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

flat_mapудовлетворяет всем требованиям контейнера, обратимого контейнера и ассоциативного контейнера.flat_mapтакже предоставляет большинство операций, описанных для уникальных ключей. Для flat_mapключ_type - Key, а значение_type - std::pair(в отличие от std::mapкакое значение_type - std::pair<constКлюч, T>.

Сравните функцию заказа для ключей (например,std::less).

Аллокатор — это распределитель для распределения значений_типов (например,allocator< std::pair>).

flat_mapпохож на std::map, но реализован как упорядоченный вектор. Это означает, что вставка нового элемента вflat_mapделает недействительными предыдущие итераторы и ссылки.

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

Этот контейнер обеспечивает итераторы случайного доступа.

Template Parameters

```
typenameKey
```
- ключ_тип карты
<
```
typenameT
```
>
<
```
typenameCompare=std::less<Key>
```
>
является функцией заказа для ключей (например,std::less).
```
typenameAllocator=new_allocator<std::pair<Key,T>>
```
является распределителем для выделенияvalue_type(например,распределитель< std::pair>.

`flat_map` public construct/copy/destruct

flat_map()noexcept(container_detail::is_nothrow_default_constructible<Allocator>::value&&container_detail::is_nothrow_default_constructible<Compare>::value));

Эффекты: По умолчанию конструирует пустоеflat_map.

Сложность: Постоянно.

```
explicitflat_map(constCompare&comp,
                 constallocator_type&a=allocator_type());
```
Эффекты: Конструирует пустоеflat_mapс помощью указанного объекта сравнения и распределителя.
Сложность: Постоянно.
```
explicitflat_map(constallocator_type&a);
```
Эффекты: Построение пустогоflat_mapс использованием указанного распределителя.
Сложность: Постоянно.
```
template<typenameInputIterator>
 flat_map(InputIteratorfirst,InputIteratorlast,
          constCompare&comp=Compare(),
          constallocator_type&a=allocator_type());
```
Эффекты: Конструирует пустоеflat_mapс использованием указанного объекта сравнения и распределителя и вставляет элементы из диапазона [первый, последний]
Сложность: Линейный в N, если диапазон [первый, последний] уже отсортирован с использованием comp и иначе N logN, где N последний — первый.
```
template<typenameInputIterator>
 flat_map(InputIteratorfirst,InputIteratorlast,constallocator_type&a);
```
Эффекты: Конструирует пустоеflat_mapс помощью указанного распределителя и вставляет элементы из диапазона [первый, последний].
Сложность: Линейный в N, если диапазон [первый, последний] уже отсортирован с использованием comp и иначе N logN, где N последний — первый.
<
```
template<typenameInputIterator>
 flat_map(ordered_unique_range_t,InputIteratorfirst,InputIteratorlast,
          constCompare&comp=Compare(),
          constallocator_type&a=allocator_type());
```
>
Эффекты: Конструирует пустое<flat_map>с помощью указанного объекта сравнения и распределителя и вставляет элементы из упорядоченного уникального диапазона [первый, последний]. Эта функция более эффективна, чем создание нормального диапазона для упорядоченных диапазонов.
Требуется: [первый, последний] должен быть упорядочен в соответствии с предикатом и должен быть уникальными значениями.
Сложность: Линейный в N.
Примечание: Нестандартное расширение.
<
```
flat_map(std::initializer_list<value_type>il,
        constCompare&comp=Compare(),
        constallocator_type&a=allocator_type());
```
>
Эффекты: Конструирует пустое<flat_map>с использованием указанного объекта сравнения и распределителя и вставляет элементы из диапазона [il.begin() ,il.end()).
Сложность: Линейный в N, если диапазон [il.begin(), il.end()) уже отсортирован с использованием comp и иначе N logN, где N последний - первый.
<
```
flat_map(std::initializer_list<value_type>il,constallocator_type&a);
```
>
Эффекты: Конструирует пустое<flat_map>с использованием указанного распределителя и вставляет элементы из диапазона [il.begin() ,il.end()).
Сложность: Линейный в N, если диапазон [il.begin(), il.end()) уже отсортирован с использованием comp и иначе N logN, где N последний - первый.
```
flat_map(ordered_unique_range_t,std::initializer_list<value_type>il,
        constCompare&comp=Compare(),
        constallocator_type&a=allocator_type());
```
Эффекты: Конструирует пустоеflat_mapс использованием указанного объекта сравнения и распределителя и вставляет элементы из упорядоченного уникального диапазона [il.begin(), il.end()). Эта функция более эффективна, чем создание нормального диапазона для упорядоченных диапазонов.
Требует: [il.begin(), il.end()) должны быть упорядочены в соответствии с предикатом и должны быть уникальными значениями.
Сложность: Линейный в N.
Примечание: Нестандартное расширение.
```
flat_map(constflat_map&x);
```
Эффекты: Копия конструируетflat_map.
Сложность: Линейный в x.size().
```
flat_map(flat_map&&x)noexcept(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value));
```
Эффекты: Строитьflat_map. Конструирует это с использованием ресурсов x.
Сложность: Постоянная.
Посткондиционное состояние: x опустошается.
```
flat_map(constflat_map&x,constallocator_type&a);
```
Эффекты: Копия конструируетflat_mapс помощью указанного распределителя.
Сложность: Линейный в x.size().
```
flat_map(flat_map&&x,constallocator_type&a);
```
Эффекты: Перемещение конструируетflat_mapс помощью указанного распределителя. Построение * этого с использованием ресурсов x.
Сложность: Постоянный, если x.get_allocator() == a, линейный иначе.
```
flat_map&operator=(constflat_map&x);
```
Эффекты: Делает это копией x.
Сложность: Линейный в x.size().
```
flat_map&operator=(flat_map&&x)noexcept((allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value)&&boost::container::container_detail::is_nothrow_move_assignable<Compare>::value));
```
Эффекты: «Движение строит»flat_map. Конструирует это с использованием ресурсов x.
Бросок: Если Allocator_traits_type::propagate_on_container_move_assignment является ложным и (броски распределения или броски конструктора движения значения_type)
Сложность: Постоянный, если allocator_traits_type:: propagate_on_container_move_assignment is true or this->get>allocator() == x.get_allocator(). Линейное иначе.
```
flat_map&operator=(std::initializer_list<value_type>il);
```
Эффекты: Назначение элементов от il до *this

`flat_map` public member functions

```
allocator_typeget_allocator()constnoexcept;
```
Эффекты: Возвращает копию распределителя, которая была передана конструктору объекта.
Сложность: Постоянная.
```
stored_allocator_type&get_stored_allocator()noexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Бросает: Ничто
Сложность: Константа.
Примечание: Нестандартное расширение.
```
conststored_allocator_type&get_stored_allocator()constnoexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Броски: Ничто
Сложность: Константа.
Примечание: Нестандартное расширение.
```
iteratorbegin()noexcept;
```
Эффекты: возвращает итератор к первому элементу, содержащемуся в контейнере.
Бросок: Ничего.
Сложность: Постоянная.
```
const_iteratorbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
iteratorend()noexcept;
```
Эффекты: Возвращает итератор в конец контейнера.
Бросает: Ничего.
Сложность: Постоянная.
<
```
const_iteratorend()constnoexcept;
```
>
Эффекты: Возвращает const_iterator в конец контейнера.
Бросает:
Сложность: Постоянство.
```
reverse_iteratorrbegin()noexcept;
```
Эффекты: Возвращает обратный_iterator, указывающий на начало обратного контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorrbegin()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратного контейнера.
Бросок: Ничего.
Сложность: Постоянная.
<
```
reverse_iteratorrend()noexcept;
```
>
Эффекты: Возвращает обратный_iterator, указывающий на конец обратного контейнера.
Бросок: Ничего.
Сложность: Постоянство.
```
const_reverse_iteratorrend()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратного контейнера.
Бросок: Ничего.
Сложность: Постоянно.
```
const_iteratorcbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
const_iteratorcend()constnoexcept;
```
Эффекты: Возвращает const_iterator в конец контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorcrbegin()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на начало обратного контейнера.
Бросает: Ничего.
Сложность: Постоянная.
```
const_reverse_iteratorcrend()constnoexcept;
```
Эффекты: Возвращает const_reverse_iterator, указывающий на конец обратного контейнера.
Бросает: Ничего.
Сложность: Постоянная.
```
boolempty()constnoexcept;
```
Эффекты: Возвращается, если контейнер не содержит элементов.
Бросок: Ничего.
Сложность: Постоянная.
```
size_typesize()constnoexcept;
```
Эффекты: Возвращает количество элементов, содержащихся в контейнере.
Бросает: Ничего.
Сложность: Постоянная.
```
size_typemax_size()constnoexcept;
```
Эффекты: Возвращает максимально возможный размер контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
size_typecapacity()constnoexcept;
```
Эффекты: Количество элементов, для которых выделена память. Вместимость () всегда больше или равна размеру ().
Бросок: Ничего.
Сложность: Постоянная.
```
voidreserve(size_typecnt);
```
Эффекты: Если n меньше или равно емкости(), этот вызов не имеет эффекта. В противном случае это запрос на выделение дополнительной памяти. Если запрос является успешным, то емкость () больше или равна n; в противном случае емкость () не изменяется. В любом случае размер() не изменяется.
Бросок: Если выделение памяти бросает, или конструктор копий Т бросает.
Примечание: Если емкость () меньше "cnt", итераторы и ссылки на значения могут быть признаны недействительными.
```
voidshrink_to_fit();
```
Эффекты: Пытается разобраться с избытком созданной памяти
Бросок: Если отбрасывает выделение памяти, или отбрасывает конструктор копий Т.
Сложность: Линейный размер().
```
mapped_type&operator[](constkey_type&k);
```
Эффекты: Если вflat_mapнет ключа, эквивалентного x, вставьте значение_type(x, T()) вflat_map
. Возвращение: Ссылка на отображенный_тип, соответствующий x в *это.
Сложность: логарифмическая.
```
mapped_type&operator[](key_type&&k);
```
Эффекты: Если вflat_mapнет ключа, эквивалентного x, то вflat_mapвставляется значение_type(move(x), T()) (ключ построен с помощью перемещения)
. Возвращение: Ссылка на отображенный_тип, соответствующий x в *это.
Сложность: Логарифмическая.
```
template<typenameM>
 std::pair<iterator,bool>insert_or_assign(constkey_type&k,M&&obj);
```
Эффекты: Если ключ, эквивалентный k, уже существует в контейнере, назначает forward(obj) на отображенный_тип, соответствующий ключу k. Если ключ не существует, вставляет новое значение как бы путем вставки, конструируя его из value_type(k, forward(obj)).
Никакие итераторы или ссылки не являются недействительными. Если вставка является успешной, указатели и ссылки на элемент, полученный во время его удерживания в ручке узла, являются недействительными, а указатели и ссылки, полученные на этот элемент до его извлечения, становятся действительными.
Возвращение: Компонент bool является истинным, если вставка имела место, и ложным, если назначение имело место. Компонент итератора указывает на элемент, который был вставлен или обновлен.
Сложность: Логарифмический размер контейнера.
<
```
template<typenameM>
 std::pair<iterator,bool>insert_or_assign(key_type&&k,M&&obj);
```
>
Эффекты: Если ключ, эквивалентный k, уже существует в контейнере, назначает forward(obj) на отображенный_тип, соответствующий ключу k. Если ключ не существует, вставляет новое значение как бы путем вставки, конструируя его из значения_type(k, move(obj)).
Никакие итераторы или ссылки не являются недействительными. Если вставка является успешной, указатели и ссылки на элемент, полученный во время его удерживания в ручке узла, являются недействительными, а указатели и ссылки, полученные на этот элемент до его извлечения, становятся действительными.
Возвращение: Компонент bool является истинным, если вставка имела место, и ложным, если назначение имело место. Компонент итератора указывает на элемент, который был вставлен или обновлен.
Сложность: Логарифмический размер контейнера.
```
template<typenameM>
 iteratorinsert_or_assign(const_iteratorhint,constkey_type&k,M&&obj);
```
Эффекты: Если ключ, эквивалентный k, уже существует в контейнере, назначает forward(obj) на отображенный_тип, соответствующий ключу k. Если ключа не существует, вставляет новое значение как бы путем вставки, конструируя его из значения_type(k, forward(obj)) и нового элемента в контейнер как можно ближе к положению непосредственно перед подсказкой.
Никакие итераторы или ссылки не являются недействительными. Если вставка является успешной, указатели и ссылки на элемент, полученный во время его удерживания в ручке узла, являются недействительными, а указатели и ссылки, полученные на этот элемент до его извлечения, становятся действительными.
Возвращение: Компонент bool является истинным, если вставка имела место, и ложным, если назначение имело место. Компонент итератора указывает на элемент, который был вставлен или обновлен.
Сложность: Логарифмическая величина контейнера в целом, но амортизированная постоянная, если новый элемент вставлен непосредственно перед подсказкой.
```
template<typenameM>
 iteratorinsert_or_assign(const_iteratorhint,key_type&&k,M&&obj);
```
Эффекты: Если ключ, эквивалентный k, уже существует в контейнере, назначает forward(obj) на отображенный_тип, соответствующий ключу k. Если ключа не существует, вставляет новое значение как бы путем вставки, конструируя его из значения_type(k, move(obj)) и нового элемента в контейнер как можно ближе к положению непосредственно перед подсказкой.
Никакие итераторы или ссылки не являются недействительными. Если вставка является успешной, указатели и ссылки на элемент, полученный во время его удерживания в ручке узла, являются недействительными, а указатели и ссылки, полученные на этот элемент до его извлечения, становятся действительными.
Возвращение: Компонент bool является истинным, если вставка имела место, и ложным, если назначение имело место. Компонент итератора указывает на элемент, который был вставлен или обновлен.
Сложность: Логарифмическая величина контейнера в целом, но амортизированная постоянная, если новый элемент вставлен непосредственно перед подсказкой.
```
iteratornth(size_typen)noexcept;
```
Требует: размер() >= n.
Эффекты: Возвращает итератор к n-му элементу от начала контейнера. Возвращает конец(), если n == размер().
Бросает: Ничего.
Сложность: Константа.
Примечание: Нестандартное расширение
```
const_iteratornth(size_typen)constnoexcept;
```
Требует: размер() >= n.
Эффекты: Возвращает const_iterator к n-му элементу с начала контейнера. Возвращает конец(), если n == размер().
Бросок: Ничего.
Сложность: Константа.
Примечание: Нестандартное расширение
```
size_typeindex_of(iteratorp)noexcept;
```
Требуется: start()<= p<= end().
Эффекты: Возвращает индекс элемента, указанный p и размером(), если p == конец().
Бросок: Ничего.
Сложность: Константа.
Примечание: Нестандартное расширение
<
```
size_typeindex_of(const_iteratorp)constnoexcept;
```
>
Требуется: start()<= p<= end().
Эффекты: Возвращает индекс элемента, указанный p и размером(), если p == конец().
Бросок: Ничего.
Сложность: Константа.
Примечание: Нестандартное расширение
```
T&at(constkey_type&k);
```
Возвращение: Ссылка на элемент, ключ которого эквивалентен x.
Броски: Объект исключения типа out_of_range, если такой элемент отсутствует.
Сложность: логарифмическая.
```
constT&at(constkey_type&k)const;
```
Возвращение: Ссылка на элемент, ключ которого эквивалентен x.
Броски: Объект исключения типа out_of_range, если такой элемент отсутствует.
Сложность: логарифмическая.
```
template<class...Args>std::pair<iterator,bool>emplace(Args&&...args);
```
Эффекты: Вставляется объект x типа T, построенный с помощью std::forward(args)... если и только если в контейнере нет элемента, эквивалентного ключу x.
Возвращается: Булевая составляющая возвращаемой пары верна тогда и только тогда, когда происходит вставка, и итераторная составляющая пары указывает на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска плюс линейная вставка в элементы с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
<
```
template<class...Args>
 iteratoremplace_hint(const_iteratorhint,Args&&...args);
```
>
Эффекты: Вставляется объект типа T, построенный с помощью std::forward(args)... в контейнер, если и только если в контейнере нет элемента с ключом, эквивалентным ключу x. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска (постоянное, если x вставлено непосредственно перед p) плюс линейная вставка к элементам с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
template<class...Args>
 std::pair<iterator,bool>try_emplace(constkey_type&k,Args&&...args);
```
Требуется: value_type должен быть EmplaceConstructible на карте от piecewise_construct, forward_as_tuple(k), forward_as_tuple(forward(args)...)
Эффекты: Если карта уже содержит элемент, ключ которого эквивалентен k, то эффекта нет. В противном случае вставляется объект типа value_type, построенный с помощью piecewise_construct, forward_as_tuple(k), forward_as_tuple(forward(args)...).
Возврат: Булевая составляющая возвращаемой пары верна, если и только если вставка имела место. Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
Сложность: Логарифмический.
<
```
template<class...Args>
 iteratortry_emplace(const_iteratorhint,constkey_type&k,
                      Args&&...args);
```
>
Требуется: value_type должен быть EmplaceConstructible в карте от piecewise_construct, forward_as_tuple(k), forward_as_tuple(forward(args)...)
Эффекты: Если карта уже содержит элемент, ключ которого эквивалентен k, то эффекта нет. В противном случае вставляется объект типа value_type, построенный с помощью piecewise_construct, forward_as_tuple(k), forward_as_tuple(forward(args)...).
Возврат: Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
Сложность: Логарифмическая в целом, но амортизированная постоянная, если значение вставлено непосредственно перед п.
```
template<class...Args>
 std::pair<iterator,bool>try_emplace(key_type&&k,Args&&...args);
```
Требуется: value_type должен быть EmplaceConstructible в карте от piecewise_construct, forward_as_tuple(move(k)), forward_as_tuple(forward(args)...)
Эффекты: Если карта уже содержит элемент, ключ которого эквивалентен k, то эффекта нет. В противном случае вставляется объект типа value_type, построенный с помощью piecewise_construct, forward_as_tuple(move(k)), forward_as_tuple(forward(args)...).
Возврат: Булевая составляющая возвращаемой пары верна, если и только если вставка имела место. Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
Сложность: Логарифмический.
```
template<class...Args>
 iteratortry_emplace(const_iteratorhint,key_type&&k,Args&&...args);
```
Требуется: значение_типа должно быть EmplaceConstructible в карте от piecewise_construct, forward_as_tuple(move(k)), forward_as_tuple(forward(args)...)
Эффекты: Если карта уже содержит элемент, ключ которого эквивалентен k, то эффекта нет. В противном случае вставляется объект типа value_type, построенный с помощью piecewise_construct, forward_as_tuple(move(k)), forward_as_tuple(forward(args)...).
Возврат: Возвращенный итератор указывает на элемент карты, ключ которого эквивалентен k.
Сложность: Логарифмическая в целом, но амортизированная постоянная, если значение вставлено непосредственно перед p.
<
```
std::pair<iterator,bool>insert(constvalue_type&x);
```
>
Эффекты: Вставляется x тогда и только тогда, когда в контейнере нет элемента с ключом, эквивалентным ключу x.
Возвращается: Компонент болта возвращаемой пары верен тогда и только тогда, когда происходит вставка, и компонент итератора пары указывает на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска плюс линейная вставка в элементы с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
std::pair<iterator,bool>insert(value_type&&x);
```
Эффекты: Вставляется новое значение_тип движения, построенное из пары, если и только если в контейнере нет элемента, эквивалентного ключу x.
Возврат: Булевая составляющая возвращаемой пары верна тогда и только тогда, когда происходит вставка, и итераторная составляющая пары указывает на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска плюс линейная вставка в элементы с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
std::pair<iterator,bool>insert(movable_value_type&&x);
```
Эффекты: Вставляется новое значение_тип движения, построенное из пары, если и только если в контейнере нет элемента, эквивалентного ключу x.
Возврат: Булевая составляющая возвращаемой пары верна тогда и только тогда, когда происходит вставка, и итераторная составляющая пары указывает на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска плюс линейная вставка в элементы с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
iteratorinsert(const_iteratorp,constvalue_type&x);
```
Эффекты: Вставляет копию x в контейнер, если и только если в контейнере нет элемента с ключом, эквивалентным ключу x. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска (постоянное, если x вставлен непосредственно перед p) плюс линейная вставка к элементам с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
iteratorinsert(const_iteratorp,value_type&&x);
```
Эффекты: Вставляет элемент, выполненный из x в контейнере. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска (постоянное, если x вставлен непосредственно перед p) плюс линейная вставка к элементам с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
<
```
iteratorinsert(const_iteratorp,movable_value_type&&x);
```
>
Эффекты: Вставляет элемент, выполненный из x в контейнере. p - подсказка, указывающая, где вставка должна начать поиск.
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным ключу x.
Сложность: Логарифмическое время поиска (постоянное, если x вставлено непосредственно перед p) плюс линейная вставка к элементам с большими клавишами, чем x.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
template<typenameInputIterator>
 voidinsert(InputIteratorfirst,InputIteratorlast);
```
Требует: первый, последний не являются итераторами в *это.
Эффекты: вставляет каждый элемент из диапазона [первый, последний], если и только если нет элемента с ключом, эквивалентным ключу этого элемента.
Сложность: Максимально N log(size()+N) (N - расстояние от первого до последнего) время поиска плюс N*size() время вставки.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
template<typenameInputIterator>
 voidinsert(ordered_unique_range_t,InputIteratorfirst,InputIteratorlast);
```
Требует: во-первых, последние не являются итераторами в *это.
Требует: [первый, последний] должен быть упорядочен в соответствии с предикатом и должен быть уникальными значениями.
Эффекты: вставляет каждый элемент из диапазона [первый, последний], если и только если нет элемента с ключом, эквивалентным ключу этого элемента. Эта функция более эффективна, чем создание нормального диапазона для упорядоченных диапазонов.
Сложность: Максимальное время поиска N log(size()+N) (N - расстояние от первого до последнего) плюс время вставки N*size().
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
Примечание: Нестандартное расширение.
```
voidinsert(std::initializer_list<value_type>il);
```
Эффекты: вставляет каждый элемент из диапазона [il.begin(), il.end()) если и только если нет элемента с ключом, эквивалентным ключу этого элемента.
Сложность: Максимально N log(size()+N) (N - расстояние от il.first() до il.end()) время поиска плюс N*size() время вставки.
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
```
voidinsert(ordered_unique_range_t,std::initializer_list<value_type>il);
```
Требует: [il.begin(), il.end()) должны быть упорядочены в соответствии с предикатом и должны быть уникальными значениями.
Эффекты: вставляет каждый элемент из диапазона [il.begin(), il.end()) если и только если нет элемента с ключом, эквивалентным ключу этого элемента. Эта функция более эффективна, чем создание нормального диапазона для упорядоченных диапазонов.
Сложность: Максимальное время поиска N log(size()+N) (N - расстояние от первого до последнего) плюс время вставки N*size().
Примечание: Если элемент вставлен, это может сделать элементы недействительными.
Примечание: Нестандартное расширение.
```
template<typenameC2>voidmerge(flat_map<Key,T,C2,Allocator>&source);
```
Требует: this->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в это, а не в источник.
Бросок: Ничего, если объект сравнения не бросит.
Сложность: N log(a.size() + N) (N имеет значение source.size())
```
template<typenameC2>voidmerge(flat_map<Key,T,C2,Allocator>&&source);
```
Требует: this->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в это, а не в источник.
Бросок: Ничего, если объект сравнения не бросит.
Сложность: N log(a.size() + N) (N имеет значение source.size())
<
```
template<typenameC2>
 voidmerge(flat_multimap<Key,T,C2,Allocator>&source);
```
>
Требуется: это->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в это, а не в источник.
Бросок: Ничего, если объект сравнения не бросает.
Сложность: N log(a.size() + N) (N имеет значение source.size())
```
template<typenameC2>
 voidmerge(flat_multimap<Key,T,C2,Allocator>&&source);
```
Требуется: это->get_allocator() == source.get_allocator().
Эффекты: Попытки извлечь каждый элемент из источника и вставить его в объект сравнения *это. Если в элементе есть ключ, эквивалентный ключу элемента из источника, то этот элемент не извлекается из источника.
Посткондиционер: Указатели и ссылки на переданные элементы источника относятся к тем же элементам, но как к членам этого. Итераторы, относящиеся к переданным элементам, будут продолжать ссылаться на их элементы, но теперь они ведут себя как итераторы в это, а не в источник.
Бросок: Ничего, если объект сравнения не бросает.
Сложность: N log(a.size() + N) (N имеет значение source.size())
<
```
iteratorerase(const_iteratorp);
```
>
Эффекты: Стирает элемент, на который указывает p.
Возвращает: Возвращает итератор, указывающий на элемент непосредственно после q перед стиранием элемента. Если такого элемента не существует, возвращается конец ().
Сложность: Линейные элементы с ключами больше, чем p
Примечание: Инвалидирует элементы ключами не меньше, чем стертый элемент.
```
size_typeerase(constkey_type&x);
```
Эффекты: Стирает все элементы в контейнере с ключом, эквивалентным x.
Возвращает: Возвращает число стертых элементов.
Сложность: Логарифмическое время поиска плюс время стирания линейно элементам с большими клавишами.
<
```
iteratorerase(const_iteratorfirst,const_iteratorlast);
```
>
Эффекты: Стирает все элементы в диапазоне [первый, последний]
Возвращает: Возвращается последним.
Сложность: размер()*N, где N — расстояние от первого до последнего.
Сложность: Логарифмическое время поиска плюс время стирания линейно элементам с большими клавишами.

voidswap(flat_map&x)noexcept(allocator_traits_type::is_always_equal::value&&boost::container::container_detail::is_nothrow_swappable<Compare>::value));

Эффекты: Перемещает содержимое этого и x.

Бросает: Ничего.

Сложность: Постоянная.

```
voidclear()noexcept;
```
Эффекты: стирание (a.begin(),a.end()).
Посткондиция: размер() == 0.
: сложность: линейный размер().
```
key_comparekey_comp()const;
```
Эффекты: Возвращает объект сравнения, из которого был построен объект сравнения.
Сложность: Постоянная.
<
```
value_comparevalue_comp()const;
```
>
Эффекты: Возвращает объект value_compare, построенный из объекта сравнения.
Сложность: Постоянно.
```
iteratorfind(constkey_type&x);
```
Возвращение: Итератор, указывающий на элемент с ключом, эквивалентным x, или конец(), если такой элемент не найден.
Сложность: Логарифмический.
```
const_iteratorfind(constkey_type&x)const;
```
Возвращение: Const_iterator указывает на элемент с ключом, эквивалентным x, или конец(), если такой элемент не найден.
Сложность: Логарифмический.
```
size_typecount(constkey_type&x)const;
```
Возвращение: Число элементов с ключом, эквивалентным x.
Сложность: log(size())+count(k)
```
iteratorlower_bound(constkey_type&x);
```
Возвращение: Итератор, указывающий на первый элемент ключом не менее k, или a.end(), если такой элемент не найден.
Сложность: Логарифмический.
```
const_iteratorlower_bound(constkey_type&x)const;
```
Возвращение: Конст-итератор, указывающий на первый элемент с ключом не менее k, или a.end(), если такой элемент не найден.
Сложность: Логарифмический.
```
iteratorupper_bound(constkey_type&x);
```
Возвращение: Итератор, указывающий на первый элемент с ключом не менее x, или конец(), если такой элемент не найден.
Сложность: Логарифмический.
```
const_iteratorupper_bound(constkey_type&x)const;
```
Возвращение: Конст-итератор, указывающий на первый элемент с ключом не менее x, или конец(), если такой элемент не найден.
Сложность: Логарифмический.
```
std::pair<iterator,iterator>equal_range(constkey_type&x);
```
Эффекты: Эквивалент std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Сложность: Логарифмический.
<
```
std::pair<const_iterator,const_iterator>
equal_range(constkey_type&x)const;
```
>
Эффекты: Эквивалент std::make_pair(this->lower_bound(k), this->upper_bound(k)).
Сложность: Логарифмический.

`flat_map` friend functions

<
```
friendbooloperator==(constflat_map&x,constflat_map&y);
```
>
Эффекты: Верно, если x и y равны
Сложность: Линейный по количеству элементов в контейнере.
<
```
friendbooloperator!=(constflat_map&x,constflat_map&y);
```
>
Эффекты: Верно, если x и y неравны
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator<(constflat_map&x,constflat_map&y);
```
Эффекты: Верно, если x меньше y
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator>(constflat_map&x,constflat_map&y);
```
Эффекты: Верно, если x больше y
Сложность: Линейный по количеству элементов в контейнере.
```
friendbooloperator<=(constflat_map&x,constflat_map&y);
```
Эффекты: Верно, если x равно или меньше y
Сложность: Линейный по количеству элементов в контейнере.
<
```
friendbooloperator>=(constflat_map&x,constflat_map&y);
```
>
Эффекты: Верно, если x равно или больше y
Сложность: Линейный по количеству элементов в контейнере.
```
friendvoidswap(flat_map&x,flat_map&y);
```
Эффекты: x.swap(y)
Сложность: Константа.

Статья Class template flat_map раздела The Boost C++ Libraries BoostBook Documentation Subset Boost.Container Header Reference может быть полезна для разработчиков на c++ и boost.

Class template flat_map

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Boost.Container Header Reference

Boost C++ Libraries

Class template flat_map

Synopsis

Description

Template Parameters

flat_map public construct/copy/destruct

flat_map public member functions

flat_map friend functions

`flat_map` public construct/copy/destruct

`flat_map` public member functions

`flat_map` friend functions