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

Class template slist

boost::container::slist

Synopsis

// In header: <boost/container/slist.hpp>
template<typename T, typename Allocator = new_allocator<T> > 
class slist {
public:
  // types
  typedef T                                                                  value_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                                             iterator;             
  typedef implementation_defined                                             const_iterator;       
  // construct/copy/destruct
  slist() noexcept(container_detail::is_nothrow_default_constructible< Allocator >::value));
  explicit slist(const allocator_type &) noexcept;
  explicit slist(size_type);
  slist(size_type, const allocator_type &);
  explicit slist(size_type, const value_type &, 
                 const allocator_type & = allocator_type());
  template<typename InpIt> 
    slist(InpIt, InpIt, const allocator_type & = allocator_type());
  slist(std::initializer_list< value_type >, 
        const allocator_type & = allocator_type());
  slist(const slist &);
  slist(slist &&) noexcept;
  slist(const slist &, const allocator_type &);
  slist(slist &&, const allocator_type &);
  slist & operator=(const slist &);
  slist & operator=(slist &&) noexcept(allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value));
  slist & operator=(std::initializer_list< value_type >);
  ~slist();
  // public member functions
  void assign(size_type, const T &);
  template<typename InpIt> void assign(InpIt, InpIt);
  void assign(std::initializer_list< value_type >);
  allocator_type get_allocator() const noexcept;
  stored_allocator_type & get_stored_allocator() noexcept;
  const stored_allocator_type & get_stored_allocator() const noexcept;
  iterator before_begin() noexcept;
  const_iterator before_begin() const noexcept;
  iterator begin() noexcept;
  const_iterator begin() const noexcept;
  iterator end() noexcept;
  const_iterator end() const noexcept;
  const_iterator cbefore_begin() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;
  iterator previous(iterator) noexcept;
  const_iterator previous(const_iterator);
  bool empty() const;
  size_type size() const;
  size_type max_size() const;
  void resize(size_type);
  void resize(size_type, const T &);
  reference front();
  const_reference front() const;
  template<class... Args> reference emplace_front(Args &&...);
  template<class... Args> iterator emplace_after(const_iterator, Args &&...);
  void push_front(const T &);
  void push_front(T &&);
  iterator insert_after(const_iterator, const T &);
  iterator insert_after(const_iterator, T &&);
  iterator insert_after(const_iterator, size_type, const value_type &);
  template<typename InpIt> iterator insert_after(const_iterator, InpIt, InpIt);
  iterator insert_after(const_iterator, std::initializer_list< value_type >);
  void pop_front();
  iterator erase_after(const_iterator);
  iterator erase_after(const_iterator, const_iterator);
  void swap(slist &) noexcept(allocator_traits_type::propagate_on_container_swap::value||allocator_traits_type::is_always_equal::value));
  void clear();
  void splice_after(const_iterator, slist &) noexcept;
  void splice_after(const_iterator, slist &&) noexcept;
  void splice_after(const_iterator, slist &, const_iterator) noexcept;
  void splice_after(const_iterator, slist &&, const_iterator) noexcept;
  void splice_after(const_iterator, slist &, const_iterator, const_iterator) noexcept;
  void splice_after(const_iterator, slist &&, const_iterator, const_iterator) noexcept;
  void splice_after(const_iterator, slist &, const_iterator, const_iterator, 
                    size_type) noexcept;
  void splice_after(const_iterator, slist &&, const_iterator, const_iterator, 
                    size_type) noexcept;
  void remove(const T &);
  template<typename Pred> void remove_if(Pred);
  void unique();
  template<typename Pred> void unique(Pred);
  void merge(slist &);
  void merge(slist &&);
  template<typename StrictWeakOrdering> 
    void merge(slist &, StrictWeakOrdering);
  template<typename StrictWeakOrdering> 
    void merge(slist &&, StrictWeakOrdering);
  void sort();
  template<typename StrictWeakOrdering> void sort(StrictWeakOrdering);
  void reverse() noexcept;
  template<class... Args> iterator emplace(const_iterator, Args &&...);
  iterator insert(const_iterator, const T &);
  iterator insert(const_iterator, T &&);
  iterator insert(const_iterator, size_type, const value_type &);
  template<typename InIter> iterator insert(const_iterator, InIter, InIter);
  iterator insert(const_iterator, std::initializer_list< value_type >);
  iterator erase(const_iterator) noexcept;
  iterator erase(const_iterator, const_iterator) noexcept;
  void splice(const_iterator, slist &) noexcept;
  void splice(const_iterator, slist &&) noexcept;
  void splice(const_iterator, slist &, const_iterator) noexcept;
  void splice(const_iterator, slist &&, const_iterator) noexcept;
  void splice(const_iterator, slist &, const_iterator, const_iterator) noexcept;
  void splice(const_iterator, slist &&, const_iterator, const_iterator) noexcept;
  // friend functions
  friend bool operator==(const slist &, const slist &);
  friend bool operator!=(const slist &, const slist &);
  friend bool operator<(const slist &, const slist &);
  friend bool operator>(const slist &, const slist &);
  friend bool operator<=(const slist &, const slist &);
  friend bool operator>=(const slist &, const slist &);
  friend void swap(slist &, slist &);
};

Description

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

Основное различие между списком и списком заключается в том, что итераторы списка являются двунаправленными итераторами, в то время как итераторы списка являются передовыми итераторами. Это означает, что список менее универсален, чем список; однако часто двунаправленные итераторы не нужны. Обычно вы должны использовать списки, если вам не нужна дополнительная функциональность списка, потому что списки с единичными ссылками меньше и быстрее, чем с двойными списками.

Важное примечание к производительности: как и любая другая последовательность, список определяет вставку и удаление функций-членов. Однако небрежное использование этих функций может привести к катастрофически медленным программам. Проблема в том, что первым аргументом вставки является итератор p, и что он вставляет новый элемент(ы) перед p. Это означает, что вставка должна найти итератор непосредственно перед p; это операция постоянного времени для списка, поскольку список имеет двунаправленные итераторы, но для списка он должен найти этот итератор, пересекая список от начала до p. Другими словами, вставка и стирание являются медленными операциями в любом месте, кроме начала списка.

Slist предоставляет функции вставки_после и удаления_после, которые являются операциями с постоянным временем: вы всегда должны использовать вставку_после и стирать_после, когда это возможно. Если вы обнаружите, что вставка_после и удаление_после не соответствуют вашим потребностям, и что вам часто нужно использовать вставку и удаление в середине списка, то вам, вероятно, следует использовать список вместо списка.

Template Parameters

```
typenameT
```
Тип объекта, который хранится в списке
<
```
typenameAllocator=new_allocator<T>
```
>
Распределитель, используемый для управления всей внутренней памятью

`slist` public construct/copy/destruct

```
slist()noexcept(container_detail::is_nothrow_default_constructible<Allocator>::value));
```
Эффекты: Составляет список, принимая в качестве параметра распределителя.
Бросок: Если выбросить конструктор копий allocator_type
Сложность: Постоянно.
```
explicitslist(constallocator_type&a)noexcept;
```
Эффекты: Составляет список, принимая в качестве параметра распределителя.
Бросает: Ничего
Сложность: Постоянно.
<
```
explicitslist(size_typen);
```
>
Эффекты: Составляет список и вставляет n инициализированных значений_типов.
Бросок: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
```
slist(size_typen,constallocator_type&a);
```
Эффекты: Составляет список, который будет использовать копию распределителя a и вставляет n копий стоимости.
Бросает: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
```
explicitslist(size_typen,constvalue_type&x,
              constallocator_type&a=allocator_type());
```
Эффекты: Составляет список, который будет использовать копию распределителя a и вставляет n копий стоимости.
Бросает: Если по умолчанию конструктор Allocator_type бросает, или по умолчанию T, или конструктор копий бросает.
Сложность: Линейный к n.
```
template<typenameInpIt>
 slist(InpItfirst,InpItlast,constallocator_type&a=allocator_type());
```
Эффекты: Создает список, который будет использовать копию распределителя а и вставляет копию диапазона [первый, последний] в список.
Бросок: Если разработчик по умолчанию Allocator_type бросает или разработчик T принимает броски InIt.
Сложность: Линейный к диапазону [первый, последний].
```
slist(std::initializer_list<value_type>il,
     constallocator_type&a=allocator_type());
```
Эффекты: Создает список, который будет использовать копию распределителя a и вставляет копию диапазона [il.begin(), il.end()) в список.
Бросок: Если конструктор по умолчанию Allocator_type бросает или конструктор T принимает отложенный std::initializer_list iterator throws.
Сложность: Линейный к диапазону [il.begin(), il.end()).
<
```
slist(constslist&x);
```
>
Эффекты: Копии составляют список.Постусловие: x == *это.
Бросает: Если конструктор по умолчанию allocator_type
Сложность: Линейные элементы, содержащие x.
```
slist(slist&&x)noexcept;
```
Эффекты: Переместите конструктор. Переносит ресурсы x на *это.
Бросает: Если бросает конструктор копий allocator_type.
Сложность: Постоянная.
```
slist(constslist&x,constallocator_type&a);
```
Эффекты: Копии строят список, используя указанный распределитель.
Посткондиционер: x == *это.
Бросает: Если конструктор по умолчанию Allocator_type
Сложность: Линейные элементы, содержащие x.
```
slist(slist&&x,constallocator_type&a);
```
Эффекты: Переместить конструктор с помощью указанного распределителя. Переносит ресурсы x на *это.
Бросает: Если вычисление или значение_типа копирует конструктор бросает.
Сложность: Постоянная, если a == x.get_allocator(), линейная иначе.
```
slist&operator=(constslist&x);
```
Эффекты: Делает *это содержит те же элементы, что и x.
Посткондиция: это->size() == x.size(). * В нем содержится копия каждого из элементов x.
Бросок: Если распределение памяти бросает или копирует конструктор Т бросает.
Сложность: Линейное число элементов в x.
```
slist&operator=(slist&&x)noexcept(allocator_traits_type::propagate_on_container_move_assignment::value||allocator_traits_type::is_always_equal::value));
```
Эффекты: Делает *это содержит те же элементы, что и x.
Посткондиция: это->size() == x.size(). * В нем содержится копия каждого из элементов x.
Бросает: Если Allocator_traits_type::propagate_on_container_move_assignment является ложным и (броски распределения или броски конструктора движения Value_type)
Сложность: Постоянная, если allocator_traits_type:: propagate_on_container_move_assignment является истинным или это->get>allocator() == x.get_allocator(). Линейное иначе.
```
slist&operator=(std::initializer_list<value_type>il);
```
Эффекты: Делает *это содержит те же элементы, что и в il.
Посткондиция: это->size() == il.size(). * В нем содержится копия каждого из элементов.
Бросок: Если Allocator_traits_type::propagate_on_container_move_assignment является ложным и (броски распределения или броски конструктора движения Value_type)
```
~slist();
```
Эффекты: Уничтожает список. Все сохраненные значения уничтожаются, а используемая память размещается.
Бросает: Ничего.
Сложность: Линейный по количеству элементов.

`slist` public member functions

```
voidassign(size_typen,constT&val);
```
Эффекты: Присваивает n копий вал к *этому.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейный к n.
```
template<typenameInpIt>voidassign(InpItfirst,InpItlast);
```
Эффекты: Назначает диапазон [первый, последний] к *этому.
Бросает: Если выделение памяти бросает или T-конструктор от отсылки к InpIt бросает.
Сложность: Линейный к n.
```
voidassign(std::initializer_list<value_type>il);
```
Эффекты: Назначает диапазон [il.begin(), il.end()) на *это.
Бросает: Если выделение памяти выбрасывает или T-конструктор из дереференцирующего std::initializer_list iterator throws.
Сложность: Линейный диапазон [il.begin(), il.end()).
```
allocator_typeget_allocator()constnoexcept;
```
Эффекты: Вернет копию внутреннего распределителя.
Бросок: Если копировщик распределителя бросит.
Сложность: Постоянно.
```
stored_allocator_type&get_stored_allocator()noexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Бросает: Ничто
Сложность: Постоянная.
Примечание: Нестандартное расширение.
```
conststored_allocator_type&get_stored_allocator()constnoexcept;
```
Эффекты: Возвращает ссылку на внутренний распределитель.
Бросает: Ничто
Сложность: Постоянная.
Примечание: Нестандартное расширение.
```
iteratorbefore_begin()noexcept;
```
Эффекты: Возвращает неотносительный итератор, который при увеличении дает начало (). Этот итератор может использоваться в качестве аргумента для вставки_after, стирания_after и т. д.
Бросок: Ничего.
Сложность: Постоянная.
<
```
const_iteratorbefore_begin()constnoexcept;
```
>
Эффекты: Возвращает неотносительный const_iterator, который при увеличении дает начало(). Этот итератор может использоваться в качестве аргумента для вставки_after, стирания_after и т. д.
Бросает: Ничего.
Сложность: Постоянно.
```
iteratorbegin()noexcept;
```
Эффекты: Возвращает итератор к первому элементу, содержащемуся в списке.
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу в списке.
Бросает: Ничего.
Сложность: Постоянно.
```
iteratorend()noexcept;
```
Эффекты: Возвращает итератор в конец списка.
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorend()constnoexcept;
```
Эффекты: Возвращает const_iterator в конец списка.
Бросает: Ничего.
Сложность: Постоянная.
```
const_iteratorcbefore_begin()constnoexcept;
```
Эффекты: Возвращает неотносительный const_iterator, который при увеличении дает начало(). Этот итератор может использоваться в качестве аргумента для вставки_after, стирания_after и т. д.
Бросок: Ничего.
Сложность: Постоянная.
```
const_iteratorcbegin()constnoexcept;
```
Эффекты: Возвращает const_iterator к первому элементу в списке.
Бросок: Ничего.
Сложность: Постоянная.
```
const_iteratorcend()constnoexcept;
```
Эффекты: Возвращает const_iterator в конец списка.
Бросок: Ничего.
Сложность: Постоянная.
<
```
iteratorprevious(iteratorp)noexcept;
```
>
Возвращение: Итератор к элементу перед i в последовательности. Возвращает конечный итератор, если i является начальным или последовательность пуста.
Бросок: Ничего.
Сложность: Линейное число элементов до i.
Примечание: Нестандартное расширение.
```
const_iteratorprevious(const_iteratorp);
```
Возвращение: Const_iterator к элементу перед i в последовательности. Возвращает конечный Const_iterator, если i является начальным Const_iterator или последовательность пуста.
Бросок: Ничего.
Сложность: Линейное число элементов до i.
Примечание: Нестандартное расширение.
```
boolempty()const;
```
Эффекты: Возвращается, если список не содержит элементов.
Бросок: Ничего.
Сложность: Постоянная.
```
size_typesize()const;
```
Эффекты: Возвращает число элементов, содержащихся в списке.
Бросает: Ничего.
Сложность: Постоянная.
```
size_typemax_size()const;
```
Эффекты: Возвращает наибольший возможный размер списка.
Бросает: Ничего.
Сложность: Постоянная.
```
voidresize(size_typenew_size);
```
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы инициализируются.
Бросок: Если отбрасывает выделение памяти, или отбрасывает конструктор копий Т.
Сложность: Линейная разница между размером () и новым размером.
```
voidresize(size_typenew_size,constT&x);
```
Эффекты: Вставляет или стирает элементы в конце так, что размер становится n. Новые элементы копируются из x.
Броски: Если отбрасывает выделение памяти, или отбрасывает конструктор копий Т.
Сложность: Линейная разница между размером () и новым размером.
```
referencefront();
```
Требует:!empty()
Эффекты: Возвращает ссылку на первый элемент из начала контейнера.
Бросок: Ничего.
Сложность: Постоянно.
```
const_referencefront()const;
```
Требует:!empty()
Эффекты: Возвращает ссылку на первый элемент из начала контейнера.
Бросок: Ничего.
Сложность: Постоянная.
```
template<class...Args>referenceemplace_front(Args&&...args);
```
Эффекты: Вставляет объект типа Т, построенный с помощью std::forward(args)... в передней части списка
Возвращение: Ссылка на созданный объект.
Бросок: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Амортизированное постоянное время.
```
template<class...Args>
 iteratoremplace_after(const_iteratorprev,Args&&...args);
```
Эффекты: Вставляется объект типа Т, построенный с помощью std::forward(args)... после прев
Бросает: Если выделение памяти бросает, или конструктор T бросает.
Сложность: постоянная
```
voidpush_front(constT&x);
```
Эффекты: В начале списка вставляется копия x.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Амортизированное постоянное время.
```
voidpush_front(T&&x);
```
Эффекты: Конструирует новый элемент в начале списка и перемещает ресурсы x в этот новый элемент.
Бросок: Если отбрасывает память.
Сложность: Амортизированное постоянное время.
```
iteratorinsert_after(const_iteratorprev_p,constT&x);
```
Требуется: p должен быть действительным итератором *этого.
Эффекты: Вставляется копия значения после prev_p.
Возврат: Итератор вставленного элемента.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Амортизированное постоянное время.
Примечание: Не влияет на достоверность итераторов и ссылок на предыдущие значения.
```
iteratorinsert_after(const_iteratorprev_p,T&&x);
```
Требуется: prev_p должен быть действительным итератором этого.
Эффекты: Вставляет сконструированный объект копирования с ходом от значения после элемента, указанного prev_p.
Возвращает: Итератор вставленного элемента.
Бросает: Если выделение памяти бросает.
Сложность: Амортизированное постоянное время.
Примечание: Не влияет на достоверность итераторов и ссылок на предыдущие значения.
```
iteratorinsert_after(const_iteratorprev_p,size_typen,
                     constvalue_type&x);
```
Требуется: prev_p должен быть действительным итератором этого.
Эффекты: Вставить n копий x после prev_p.
Возвращение: итератор до последнего вставленного элемента или prev_p, если n равно 0.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейный к n.
Примечание: Не влияет на достоверность итераторов и ссылок на предыдущие значения.
```
template<typenameInpIt>
 iteratorinsert_after(const_iteratorprev_p,InpItfirst,InpItlast);
```
Требуется: prev_p должен быть действительным итератором этого.
Эффекты: Вставляется диапазон, указанный [первым, последним] после prev_p.
Возвращается: итератор до последнего вставленного элемента или prev_p, если первый == последний.
Бросает: Если выделение памяти бросает, конструктор Т из отнесенного к делу InpIt бросает.
Сложность: Линейное число вставленных элементов
Примечание: Не влияет на достоверность итераторов и ссылок на предыдущие значения.
<
```
iteratorinsert_after(const_iteratorprev_p,
                     std::initializer_list<value_type>il);
```
>
Требуется: prev_p должен быть действительным итератором этого.
Эффекты: Вставляет диапазон, указанный [il.begin(), il.end()) после prev_p.
Возвращает: итератор к последнему вставленному элементу или prev_p, если il.begin() == il.end().
Бросает: Если выделение памяти бросает, T's конструктор из отнесенного std::initializer_list итератор бросает.
Сложность: Линейный по количеству вставленных элементов.
Примечание: Не влияет на достоверность итераторов и ссылок на предыдущие значения.
```
voidpop_front();
```
Эффекты: Удалите первый элемент из списка.
Бросает: Ничего.
Сложность: Амортизированное постоянное время.
```
iteratorerase_after(const_iteratorprev_p);
```
Эффекты: Стирает элемент после элемента, указанного prev_p списка.
Возвращает: первый элемент, остающийся за пределами удаленных элементов, или конец(), если такой элемент не существует.
Бросок: Ничего.
Сложность: Константа.
Примечание: Не делает недействительными итераторы или ссылки на не стертые элементы.
<
```
iteratorerase_after(const_iteratorbefore_first,const_iteratorlast);
```
>
Эффекты: Стирает диапазон (до_первого, последнего) из списка.
Возвращение: первый элемент, остающийся за пределами удаленных элементов, или конец (), если такой элемент не существует.
Бросок: Ничего.
Сложность: Линейный по количеству стертых элементов.
Примечание: Не делает недействительными итераторы или ссылки на не стертые элементы.
```
voidswap(slist&x)noexcept(allocator_traits_type::propagate_on_container_swap::value||allocator_traits_type::is_always_equal::value));
```
Эффекты: Измените содержание *это и x.
Бросает: Ничего.
Сложность: Линейное число элементов на *это и x.
```
voidclear();
```
Эффекты: Стирает все элементы списка.
Бросок: Ничего.
Сложность: Линейный по количеству элементов в списке.
```
voidsplice_after(const_iteratorprev_p,slist&x)noexcept;
```
Требуется: p должен указывать на элемент, содержащийся в списке. x!= *это
Эффекты: Переносит все элементы списка x в этот список после элемента, указанного p. Ни разрушители, ни конструкторы копий не называются.
Броски: std::runtime_error, если этот' распределитель и x' распределитель не равны.
Сложность: Линейные элементы в x.
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice_after(const_iteratorprev_p,slist&&x)noexcept;
```
Требуется: p должен указывать на элемент, содержащийся в списке. x!= *это
Эффекты: Переносит все элементы списка x в этот список после элемента, указанного p. Ни разрушители, ни конструкторы копий не называются.
Броски: std::runtime_error, если этот' распределитель и x' распределитель не равны.
Сложность: Линейные элементы в x.
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice_after(const_iteratorprev_p,slist&x,const_iteratorprev)noexcept;
```
Требуется: prev_p должен быть действительным итератором этого. Я должен указать на элемент, содержащийся в списке x. Этот распределитель и распределитель x должны сравниваться равными.
: Переносит значение, указанное i, из списка x в этот список, после элемента, указанного prev_p. Если prev_p == prev или prev_p == ++prev, эта функция является нулевой операцией.
Броски: Ничто
Сложность: Постоянная.
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice_after(const_iteratorprev_p,slist&&x,const_iteratorprev)noexcept;
```
Требуется: prev_p должен быть действительным итератором этого. Я должен указать на элемент, содержащийся в списке x. Этот распределитель и распределитель x должны сравниваться равными.
Эффекты: Переносит значение, указанное i, из списка x в этот список, после элемента, указанного prev_p. Если prev_p == prev или prev_p == ++prev, эта функция является нулевой операцией.
Броски: Ничто
Сложность:
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice_after(const_iteratorprev_p,slist&x,
                 const_iteratorbefore_first,const_iteratorbefore_last)noexcept;
```
Требуется: prev_p должен быть действительным итератором этого. Перед_first и перед_last должны быть действительными итераторами x. prev_p не должен содержаться в [до_первого, до_последнего] диапазоне. Этот распределитель и распределитель x должны сравниваться равными.
Эффекты: Переносит диапазон [before_first + 1, before_last + 1] из списка x в этот список, после элемента, указанного prev_p.
Бросает: Ничто
Сложность: Линейное число переданных элементов.
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice_after(const_iteratorprev_p,slist&&x,
                 const_iteratorbefore_first,const_iteratorbefore_last)noexcept;
```
Требуется: prev_p должен быть действительным итератором этого. Перед_first и перед_last должны быть действительными итераторами x. prev_p не должен содержаться в [до_первого, до_последнего] диапазоне. Этот распределитель и распределитель x должны сравниваться равными.
Эффекты: Переносит диапазон [before_first + 1, before_last + 1] из списка x в этот список, после элемента, указанного prev_p.
Бросает: Ничто
Сложность: Линейный по количеству переданных элементов.
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice_after(const_iteratorprev_p,slist&x,
                 const_iteratorbefore_first,const_iteratorbefore_last,
                 size_typen)noexcept;
```
Требуется: prev_p должен быть действительным итератором этого. Перед_first и перед_last должны быть действительными итераторами x. prev_p не должен содержаться в [before_first, before_last] диапазоне. n == расстояние (before_first, before_last). Этот распределитель и распределитель x должны сравниваться равными.
Эффекты: Переносит диапазон [до_первого + 1, до_последнего + 1] из списка x в этот список, после элемента, указанного prev_p.
Бросает: Ничто
Сложность: Константа.
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice_after(const_iteratorprev_p,slist&&x,
                 const_iteratorbefore_first,const_iteratorbefore_last,
                 size_typen)noexcept;
```
Требуется: prev_p должен быть действительным итератором этого. Перед_first и перед_last должны быть действительными итераторами x. prev_p не должен содержаться в [before_first, before_last] диапазоне. n == расстояние (before_first, before_last). Этот распределитель и распределитель x должны сравниваться равными.
Эффекты: Переносит диапазон [before_first + 1, before_last + 1] из списка x в этот список, после элемента, указанного prev_p.
Бросает: Ничто
Сложность:
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidremove(constT&value);
```
Эффекты: Удалите все элементы, которые сравниваются с величиной.
Бросает: Ничего.
Сложность: Линейное время. Он выполняет точное сравнение размеров () для равенства.
Примечание: Относительный порядок элементов, которые не удаляются, не изменяется, и итераторы элементов, которые не удаляются, остаются действительными.
```
template<typenamePred>voidremove_if(Predpred);
```
Эффекты: Удаляет все элементы, для которых удовлетворяется заданный предикат.
Бросок: Если предки бросают.
Сложность: Линейное время. Он выполняет точно размер() вызовов к предикату.
Примечание: Относительный порядок элементов, которые не удаляются, не изменяется, и итераторы элементов, которые не удаляются, остаются действительными.
```
voidunique();
```
Эффекты: Удалите соседние дублирующие элементы или соседние элементы, которые равны из списка.
Бросок: Если сравнивать броски.
Сложность: Линейное время (размер()-1 сравнений равенства).
Примечание: Относительный порядок элементов, которые не удаляются, не изменяется, и итераторы элементов, которые не удаляются, остаются действительными.
```
template<typenamePred>voidunique(Predpred);
```
Эффекты: Удаляет соседние дублирующие элементы или соседние элементы, удовлетворяющие некоторому двоичному предикату из списка.
Броски: Если предки бросают.
Сложность: Линейное время (размер()-1 сравнения вызывает пред()).
Примечание: Относительный порядок элементов, которые не удаляются, не изменяется, и итераторы элементов, которые не удаляются, остаются действительными.
```
voidmerge(slist&x);
```
Требуется: Списки x и * должны быть различными.
Эффекты: Эта функция удаляет все элементы x и вставляет их в порядок в соответствии со std::less. Слияние стабильно; то есть, если элемент из *это эквивалентно элементу из x, то элемент из *это будет предшествовать элементу из x.
Бросает: Если сравнивать броски.
Сложность: Эта функция является линейным временем: она выполняет максимум размер() + x.size() - 1 сравнение.
```
voidmerge(slist&&x);
```
Требуется: Списки x и * это должны быть различными.
Эффекты: Эта функция удаляет все элементы x и вставляет их в порядок в соответствии со std::less. Слияние стабильно; то есть, если элемент из *это эквивалентно элементу из x, то элемент из *это будет предшествовать элементу из x.
Бросает: Если сравнивать броски.
Сложность: Эта функция является линейным временем: она выполняет максимум размер() + x.size() - 1 сравнение.
```
template<typenameStrictWeakOrdering>
 voidmerge(slist&x,StrictWeakOrderingcomp);
```
Требуется: p должна быть функцией сравнения, которая вызывает строгое слабое упорядочение, и оба *это и x должны быть отсортированы в соответствии с этим упорядочением. Списки x и * должны быть различными.
Эффекты: Эта функция удаляет все элементы x и вставляет их в *это. Слияние стабильно; то есть, если элемент из * это эквивалентно элементу из x, то элемент из * это будет предшествовать элементу из x.
Бросает: Если комп бросает.
Сложность: Эта функция является линейным временем: она выполняет максимум размер() + x.size() - 1 сравнение.
Примечание: Итераторы и ссылки на * это не являются недействительными.
```
template<typenameStrictWeakOrdering>
 voidmerge(slist&&x,StrictWeakOrderingcomp);
```
Требуется: p должна быть функцией сравнения, которая вызывает строгую слабую упорядоченность, и как это, так и x должны быть отсортированы в соответствии с этой упорядоченностью. Списки x и * должны быть различными.
Эффекты: Эта функция удаляет все элементы x и вставляет их в *это. Слияние стабильно; то есть, если элемент из * это эквивалентно элементу из x, то элемент из * это будет предшествовать элементу из x.
Бросает: Если комп бросает.
Сложность: Эта функция является линейным временем: она выполняет максимум размер() + x.size() - 1 сравнение.
Примечание: Итераторы и ссылки на * это не являются недействительными.
```
voidsort();
```
Эффекты: Эта функция сортирует список *это согласно std::less. Сорт стабилен, то есть сохраняется относительный порядок эквивалентных элементов.
Броски:
Примечания: Итераторы и ссылки не являются недействительными.
Сложность: Количество сравнений приблизительно равно N log N, где N — размер списка.
```
template<typenameStrictWeakOrdering>voidsort(StrictWeakOrderingcomp);
```
Эффекты: Эта функция сортирует список *это согласно std::less. Сорт стабилен, то есть сохраняется относительный порядок эквивалентных элементов.
Бросок: Если комп бросает.
Примечания: Итераторы и ссылки не являются недействительными.
Сложность: Количество сравнений приблизительно равно N log N, где N — размер списка.
<
```
voidreverse()noexcept;
```
>
Эффекты: Обратный порядок элементов в списке
Бросает: Ничего.
Сложность: Эта функция является линейным временем.
Примечание: Итераторы и ссылки не являются недействительными
.
```
template<class...Args>iteratoremplace(const_iteratorp,Args&&...args);
```
Эффекты: Вставляется объект типа Т, построенный с помощью std::forward(args)... до p
Бросает: Если выделение памяти бросает, или конструктор T бросает.
Сложность: Линейные элементы до p
```
iteratorinsert(const_iteratorp,constT&x);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставить копию x перед p.
Возвращает: итератор к вставленному элементу.
Бросок: Если выделение памяти бросает или копирует конструктор x.
Сложность: Линейные элементы до p.
```
iteratorinsert(const_iteratorprev_p,T&&x);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставьте новый элемент перед p с ресурсами x.
Возвращает: итератор на вставленный элемент.
Бросок: Если выделение памяти бросает.
Сложность: Линейные элементы до п.
```
iteratorinsert(const_iteratorp,size_typen,constvalue_type&x);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставить n копий x перед p.
Возвращение: итератор первого вставленного элемента или p, если n == 0.
Бросает: Если выделение памяти бросит или конструктор копий Т бросит.
Сложность: Линейный к n плюс линейный к элементам до p.
```
template<typenameInIter>
 iteratorinsert(const_iteratorp,InIterfirst,InIterlast);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставить копию [первого, последнего] диапазона перед p.
Возвращение: итератор первого вставленного элемента или p, если первый == последний.
Бросает: Если выделение памяти бросает, конструктор Т из отнесенного к делу InpIt бросает.
Сложность: Линейный к расстоянию [первый, последний] плюс линейный к элементам до p.
```
iteratorinsert(const_iteratorp,std::initializer_list<value_type>il);
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Вставить копию диапазона [il.begin(), il.end()) перед p.
Возвращает: итератор к первому вставленному элементу или p, если il.begin() == il.end().
Бросает: Если выделение памяти бросает, конструктор Т из отнесенного к делу std::initializer_list iterator throws.
Сложность: Линейный к диапазону [il.begin(), il.end()) плюс линейный к элементам до p.
```
iteratorerase(const_iteratorp)noexcept;
```
Требуется: p должен быть действительным итератором этого.
Эффекты: Стирает элемент по п.
Бросает: Ничего.
Сложность: Линейное число элементов до стр.
```
iteratorerase(const_iteratorfirst,const_iteratorlast)noexcept;
```
Требует: первый и последний должны быть действительным итератором элементов в *это.
Эффекты: Стирает элементы, указанные [первым, последним].
Бросает: Ничего.
Сложность: Линейное расстояние между первым и последним плюс линейное к элементам перед первым.
```
voidsplice(const_iteratorp,slist&x)noexcept;
```
Требуется: p должен указывать на элемент, содержащийся в списке. x!= *это. этот распределитель и распределитель x должны сравнивать равные
Эффекты: Переносит все элементы списка x в этот список перед элементом, указанным p. Ни разрушители, ни конструкторы копий не называются.
Броски: Ничто
Сложность: Линейный в расстоянии (begin(), p) и линейный в x.size().
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
<
```
voidsplice(const_iteratorp,slist&&x)noexcept;
```
>
Требуется: p должен указывать на элемент, содержащийся в списке. x!= *это. этот распределитель и распределитель x должны сравнивать равные
эффекты: Переносит все элементы списка x в этот список перед элементом, указанным p. Ни разрушители, ни конструкторы копий не называются.
Броски: Ничего
Сложность: Линейный в расстоянии (begin(), p) и линейный в x.size().
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice(const_iteratorp,slist&x,const_iteratori)noexcept;
```
Требуется: p должен указывать на элемент, содержащийся в этом списке. Я должен указать на элемент, содержащийся в списке x. Этот распределитель и распределитель x должны сравнивать равные
Эффекты: Переносит значение, указанное i, из списка x в этот список, перед элементом, указанным p. Ни разрушители, ни конструкторы копий не называются. Если p == i или p == ++i, эта функция является нулевой операцией.
Броски: Ничего
Сложность: Линейный в расстоянии (начало(), р) и в расстоянии (x.begin(), i).
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice(const_iteratorp,slist&&x,const_iteratori)noexcept;
```
Требуется: p должен указывать на элемент, содержащийся в этом списке. Я должен указать на элемент, содержащийся в списке x. Этот распределитель и распределитель x должны сравниваться равными.
Эффекты: Переносит значение, указанное i, из списка x в этот список, перед элементом, указанным p. Ни разрушители, ни конструкторы копий не называются. Если p == i или p == ++i, эта функция является нулевой операцией.
Броски: Ничто
Сложность: Линейный в расстоянии (начало(), р) и в расстоянии (x.begin(), i).
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice(const_iteratorp,slist&x,const_iteratorfirst,
           const_iteratorlast)noexcept;
```
Требуется: p должен указывать на элемент, содержащийся в этом списке. Первый и последний должны указывать на элементы, содержащиеся в списке x.
Эффекты: Переносит диапазон, указанный первым и последним из списка x в этот список, перед элементом, указанным p. Ни разрушители, ни конструкторы копий не называются. Этот распределитель и распределитель x должны сравниваться равными.
Броски: Ничто
Сложность: Линейный в расстоянии (начало(), р), в расстоянии (x.begin(), первый), и в расстоянии (первый, последний).
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.
```
voidsplice(const_iteratorp,slist&&x,const_iteratorfirst,
           const_iteratorlast)noexcept;
```
Требуется: p должен указывать на элемент, содержащийся в этом списке. Первый и последний должны указывать на элементы, содержащиеся в списке x. Этот распределитель и распределитель x должны сравнивать равные
эффекты: Переносит диапазон, указанный первым и последним из списка x в этот список, перед элементом, указанным p. Ни разрушители, ни конструкторы копий не называются.
Броски: Ничто
Сложность: Линейный в расстоянии (начало(), р), в расстоянии (x.begin(), первый), и в расстоянии (первый, последний).
Примечание: Итераторы значений, полученных из списка x, теперь указывают на элементы этого списка. Итераторы этого списка и все ссылки не являются недействительными.

`slist` friend functions

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

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

Class template slist

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

Boost C++ Libraries

Class template slist

Synopsis

Description

Template Parameters

slist public construct/copy/destruct

slist public member functions

slist friend functions

`slist` public construct/copy/destruct

`slist` public member functions

`slist` friend functions