STL_list

 STL_list

  /**   *  @brief A standard container with linear time access to elements,   *  and fixed time insertion/deletion at any point in the sequence.   *   *  @ingroup sequences   *   *  Meets the requirements of a <a href="tables.html#65">container</a>, a   *  <a href="tables.html#66">reversible container</a>, and a   *  <a href="tables.html#67">sequence</a>, including the   *  <a href="tables.html#68">optional sequence requirements</a> with the   *  %exception of @c at and @c operator[].   *   *  This is a @e doubly @e linked %list.  Traversal up and down the   *  %list requires linear time, but adding and removing elements (or   *  @e nodes) is done in constant time, regardless of where the   *  change takes place.  Unlike std::vector and std::deque,   *  random-access iterators are not provided, so subscripting ( @c   *  [] ) access is not allowed.  For algorithms which only need   *  sequential access, this lack makes no difference.   *   *  Also unlike the other standard containers, std::list provides   *  specialized algorithms %unique to linked lists, such as   *  splicing, sorting, and in-place reversal.   *   *  A couple points on memory allocation for list<Tp>:   *   *  First, we never actually allocate a Tp, we allocate   *  List_node<Tp>'s and trust [20.1.5]/4 to DTRT.  This is to ensure   *  that after elements from %list<X,Alloc1> are spliced into   *  %list<X,Alloc2>, destroying the memory of the second %list is a   *  valid operation, i.e., Alloc1 giveth and Alloc2 taketh away.   *   *  Second, a %list conceptually represented as   *  @code   *    A <---> B <---> C <---> D   *  @endcode   *  is actually circular; a link exists between A and D.  The %list   *  class holds (as its only data member) a private list::iterator   *  pointing to @e D, not to @e A!  To get to the head of the %list,   *  we start at the tail and move forward by one.  When this member   *  iterator's next/previous pointers refer to itself, the %list is   *  %empty.   */  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >    class list : protected _List_base<_Tp, _Alloc>    {      // concept requirements      typedef typename _Alloc::value_type                _Alloc_value_type;      __glibcxx_class_requires(_Tp, _SGIAssignableConcept)      __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept)      typedef _List_base<_Tp, _Alloc>                    _Base;      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;    public:      typedef _Tp                                        value_type;      typedef typename _Tp_alloc_type::pointer           pointer;      typedef typename _Tp_alloc_type::const_pointer     const_pointer;      typedef typename _Tp_alloc_type::reference         reference;      typedef typename _Tp_alloc_type::const_reference   const_reference;      typedef _List_iterator<_Tp>                        iterator;      typedef _List_const_iterator<_Tp>                  const_iterator;      typedef std::reverse_iterator<const_iterator>      const_reverse_iterator;      typedef std::reverse_iterator<iterator>            reverse_iterator;      typedef size_t                                     size_type;      typedef ptrdiff_t                                  difference_type;      typedef _Alloc                                     allocator_type;    protected:      // Note that pointers-to-_Node's can be ctor-converted to      // iterator types.      typedef _List_node<_Tp> _Node;      using _Base::_M_impl;      using _Base::_M_put_node;      using _Base::_M_get_node;      using _Base::_M_get_Tp_allocator;      using _Base::_M_get_Node_allocator;      /**       *  @param  x  An instance of user data.       *       *  Allocates space for a new node and constructs a copy of @a x in it.       */#ifndef __GXX_EXPERIMENTAL_CXX0X__      _Node*      _M_create_node(const value_type& __x)      {_Node* __p = this->_M_get_node();__try  {    _M_get_Tp_allocator().construct(&__p->_M_data, __x);  }__catch(...)  {    _M_put_node(__p);    __throw_exception_again;  }return __p;      }#else      template<typename... _Args>        _Node*        _M_create_node(_Args&&... __args){  _Node* __p = this->_M_get_node();  __try    {      _M_get_Node_allocator().construct(__p,std::forward<_Args>(__args)...);    }  __catch(...)    {      _M_put_node(__p);      __throw_exception_again;    }  return __p;}#endif    public:      // [23.2.2.1] construct/copy/destroy      // (assign() and get_allocator() are also listed in this section)      /**       *  @brief  Default constructor creates no elements.       */      list()      : _Base() { }      /**       *  @brief  Creates a %list with no elements.       *  @param  a  An allocator object.       */      explicit      list(const allocator_type& __a)      : _Base(__a) { }      /**       *  @brief  Creates a %list with copies of an exemplar element.       *  @param  n  The number of elements to initially create.       *  @param  value  An element to copy.       *  @param  a  An allocator object.       *       *  This constructor fills the %list with @a n copies of @a value.       */      explicit      list(size_type __n, const value_type& __value = value_type(),   const allocator_type& __a = allocator_type())      : _Base(__a)      { _M_fill_initialize(__n, __value); }      /**       *  @brief  %List copy constructor.       *  @param  x  A %list of identical element and allocator types.       *       *  The newly-created %list uses a copy of the allocation object used       *  by @a x.       */      list(const list& __x)      : _Base(__x._M_get_Node_allocator())      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }#ifdef __GXX_EXPERIMENTAL_CXX0X__      /**       *  @brief  %List move constructor.       *  @param  x  A %list of identical element and allocator types.       *       *  The newly-created %list contains the exact contents of @a x.       *  The contents of @a x are a valid, but unspecified %list.       */      list(list&& __x)      : _Base(std::forward<_Base>(__x)) { }      /**       *  @brief  Builds a %list from an initializer_list       *  @param  l  An initializer_list of value_type.       *  @param  a  An allocator object.       *       *  Create a %list consisting of copies of the elements in the       *  initializer_list @a l.  This is linear in l.size().       */      list(initializer_list<value_type> __l,           const allocator_type& __a = allocator_type())      : _Base(__a)      { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }#endif      /**       *  @brief  Builds a %list from a range.       *  @param  first  An input iterator.       *  @param  last  An input iterator.       *  @param  a  An allocator object.       *       *  Create a %list consisting of copies of the elements from       *  [@a first,@a last).  This is linear in N (where N is       *  distance(@a first,@a last)).       */      template<typename _InputIterator>        list(_InputIterator __first, _InputIterator __last,     const allocator_type& __a = allocator_type())        : _Base(__a)        {   // Check whether it's an integral type.  If so, it's not an iterator.  typedef typename std::__is_integer<_InputIterator>::__type _Integral;  _M_initialize_dispatch(__first, __last, _Integral());}      /**       *  No explicit dtor needed as the _Base dtor takes care of       *  things.  The _Base dtor only erases the elements, and note       *  that if the elements themselves are pointers, the pointed-to       *  memory is not touched in any way.  Managing the pointer is       *  the user's responsibility.       */      /**       *  @brief  %List assignment operator.       *  @param  x  A %list of identical element and allocator types.       *       *  All the elements of @a x are copied, but unlike the copy       *  constructor, the allocator object is not copied.       */      list&      operator=(const list& __x);#ifdef __GXX_EXPERIMENTAL_CXX0X__      /**       *  @brief  %List move assignment operator.       *  @param  x  A %list of identical element and allocator types.       *       *  The contents of @a x are moved into this %list (without copying).       *  @a x is a valid, but unspecified %list       */      list&      operator=(list&& __x)      {// NB: DR 1204.// NB: DR 675.this->clear();this->swap(__x);return *this;      }      /**       *  @brief  %List initializer list assignment operator.       *  @param  l  An initializer_list of value_type.       *       *  Replace the contents of the %list with copies of the elements       *  in the initializer_list @a l.  This is linear in l.size().       */      list&      operator=(initializer_list<value_type> __l)      {this->assign(__l.begin(), __l.end());return *this;      }#endif      /**       *  @brief  Assigns a given value to a %list.       *  @param  n  Number of elements to be assigned.       *  @param  val  Value to be assigned.       *       *  This function fills a %list with @a n copies of the given       *  value.  Note that the assignment completely changes the %list       *  and that the resulting %list's size is the same as the number       *  of elements assigned.  Old data may be lost.       */      void      assign(size_type __n, const value_type& __val)      { _M_fill_assign(__n, __val); }      /**       *  @brief  Assigns a range to a %list.       *  @param  first  An input iterator.       *  @param  last   An input iterator.       *       *  This function fills a %list with copies of the elements in the       *  range [@a first,@a last).       *       *  Note that the assignment completely changes the %list and       *  that the resulting %list's size is the same as the number of       *  elements assigned.  Old data may be lost.       */      template<typename _InputIterator>        void        assign(_InputIterator __first, _InputIterator __last)        {  // Check whether it's an integral type.  If so, it's not an iterator.  typedef typename std::__is_integer<_InputIterator>::__type _Integral;  _M_assign_dispatch(__first, __last, _Integral());}#ifdef __GXX_EXPERIMENTAL_CXX0X__      /**       *  @brief  Assigns an initializer_list to a %list.       *  @param  l  An initializer_list of value_type.       *       *  Replace the contents of the %list with copies of the elements       *  in the initializer_list @a l.  This is linear in l.size().       */      void      assign(initializer_list<value_type> __l)      { this->assign(__l.begin(), __l.end()); }#endif      /// Get a copy of the memory allocation object.      allocator_type      get_allocator() const      { return _Base::get_allocator(); }      // iterators      /**       *  Returns a read/write iterator that points to the first element in the       *  %list.  Iteration is done in ordinary element order.       */      iterator      begin()      { return iterator(this->_M_impl._M_node._M_next); }      /**       *  Returns a read-only (constant) iterator that points to the       *  first element in the %list.  Iteration is done in ordinary       *  element order.       */      const_iterator      begin() const      { return const_iterator(this->_M_impl._M_node._M_next); }      /**       *  Returns a read/write iterator that points one past the last       *  element in the %list.  Iteration is done in ordinary element       *  order.       */      iterator      end()      { return iterator(&this->_M_impl._M_node); }      /**       *  Returns a read-only (constant) iterator that points one past       *  the last element in the %list.  Iteration is done in ordinary       *  element order.       */      const_iterator      end() const      { return const_iterator(&this->_M_impl._M_node); }      /**       *  Returns a read/write reverse iterator that points to the last       *  element in the %list.  Iteration is done in reverse element       *  order.       */      reverse_iterator      rbegin()      { return reverse_iterator(end()); }      /**       *  Returns a read-only (constant) reverse iterator that points to       *  the last element in the %list.  Iteration is done in reverse       *  element order.       */      const_reverse_iterator      rbegin() const      { return const_reverse_iterator(end()); }      /**       *  Returns a read/write reverse iterator that points to one       *  before the first element in the %list.  Iteration is done in       *  reverse element order.       */      reverse_iterator      rend()      { return reverse_iterator(begin()); }      /**       *  Returns a read-only (constant) reverse iterator that points to one       *  before the first element in the %list.  Iteration is done in reverse       *  element order.       */      const_reverse_iterator      rend() const      { return const_reverse_iterator(begin()); }#ifdef __GXX_EXPERIMENTAL_CXX0X__      /**       *  Returns a read-only (constant) iterator that points to the       *  first element in the %list.  Iteration is done in ordinary       *  element order.       */      const_iterator      cbegin() const      { return const_iterator(this->_M_impl._M_node._M_next); }      /**       *  Returns a read-only (constant) iterator that points one past       *  the last element in the %list.  Iteration is done in ordinary       *  element order.       */      const_iterator      cend() const      { return const_iterator(&this->_M_impl._M_node); }      /**       *  Returns a read-only (constant) reverse iterator that points to       *  the last element in the %list.  Iteration is done in reverse       *  element order.       */      const_reverse_iterator      crbegin() const      { return const_reverse_iterator(end()); }      /**       *  Returns a read-only (constant) reverse iterator that points to one       *  before the first element in the %list.  Iteration is done in reverse       *  element order.       */      const_reverse_iterator      crend() const      { return const_reverse_iterator(begin()); }#endif      // [23.2.2.2] capacity      /**       *  Returns true if the %list is empty.  (Thus begin() would equal       *  end().)       */      bool      empty() const      { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }      /**  Returns the number of elements in the %list.  */      size_type      size() const      { return std::distance(begin(), end()); }      /**  Returns the size() of the largest possible %list.  */      size_type      max_size() const      { return _M_get_Node_allocator().max_size(); }      /**       *  @brief Resizes the %list to the specified number of elements.       *  @param new_size Number of elements the %list should contain.       *  @param x Data with which new elements should be populated.       *       *  This function will %resize the %list to the specified number       *  of elements.  If the number is smaller than the %list's       *  current size the %list is truncated, otherwise the %list is       *  extended and new elements are populated with given data.       */      void      resize(size_type __new_size, value_type __x = value_type());      // element access      /**       *  Returns a read/write reference to the data at the first       *  element of the %list.       */      reference      front()      { return *begin(); }      /**       *  Returns a read-only (constant) reference to the data at the first       *  element of the %list.       */      const_reference      front() const      { return *begin(); }      /**       *  Returns a read/write reference to the data at the last element       *  of the %list.       */      reference      back()      { iterator __tmp = end();--__tmp;return *__tmp;      }      /**       *  Returns a read-only (constant) reference to the data at the last       *  element of the %list.       */      const_reference      back() const      { const_iterator __tmp = end();--__tmp;return *__tmp;      }      // [23.2.2.3] modifiers      /**       *  @brief  Add data to the front of the %list.       *  @param  x  Data to be added.       *       *  This is a typical stack operation.  The function creates an       *  element at the front of the %list and assigns the given data       *  to it.  Due to the nature of a %list this operation can be       *  done in constant time, and does not invalidate iterators and       *  references.       */      void      push_front(const value_type& __x)      { this->_M_insert(begin(), __x); }#ifdef __GXX_EXPERIMENTAL_CXX0X__      void      push_front(value_type&& __x)      { this->_M_insert(begin(), std::move(__x)); }      template<typename... _Args>        void        emplace_front(_Args&&... __args)        { this->_M_insert(begin(), std::forward<_Args>(__args)...); }#endif      /**       *  @brief  Removes first element.       *       *  This is a typical stack operation.  It shrinks the %list by       *  one.  Due to the nature of a %list this operation can be done       *  in constant time, and only invalidates iterators/references to       *  the element being removed.       *       *  Note that no data is returned, and if the first element's data       *  is needed, it should be retrieved before pop_front() is       *  called.       */      void      pop_front()      { this->_M_erase(begin()); }      /**       *  @brief  Add data to the end of the %list.       *  @param  x  Data to be added.       *       *  This is a typical stack operation.  The function creates an       *  element at the end of the %list and assigns the given data to       *  it.  Due to the nature of a %list this operation can be done       *  in constant time, and does not invalidate iterators and       *  references.       */      void      push_back(const value_type& __x)      { this->_M_insert(end(), __x); }#ifdef __GXX_EXPERIMENTAL_CXX0X__      void      push_back(value_type&& __x)      { this->_M_insert(end(), std::move(__x)); }      template<typename... _Args>        void        emplace_back(_Args&&... __args)        { this->_M_insert(end(), std::forward<_Args>(__args)...); }#endif      /**       *  @brief  Removes last element.       *       *  This is a typical stack operation.  It shrinks the %list by       *  one.  Due to the nature of a %list this operation can be done       *  in constant time, and only invalidates iterators/references to       *  the element being removed.       *       *  Note that no data is returned, and if the last element's data       *  is needed, it should be retrieved before pop_back() is called.       */      void      pop_back()      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }#ifdef __GXX_EXPERIMENTAL_CXX0X__      /**       *  @brief  Constructs object in %list before specified iterator.       *  @param  position  A const_iterator into the %list.       *  @param  args  Arguments.       *  @return  An iterator that points to the inserted data.       *       *  This function will insert an object of type T constructed       *  with T(std::forward<Args>(args)...) before the specified       *  location.  Due to the nature of a %list this operation can       *  be done in constant time, and does not invalidate iterators       *  and references.       */      template<typename... _Args>        iterator        emplace(iterator __position, _Args&&... __args);#endif      /**       *  @brief  Inserts given value into %list before specified iterator.       *  @param  position  An iterator into the %list.       *  @param  x  Data to be inserted.       *  @return  An iterator that points to the inserted data.       *       *  This function will insert a copy of the given value before       *  the specified location.  Due to the nature of a %list this       *  operation can be done in constant time, and does not       *  invalidate iterators and references.       */      iterator      insert(iterator __position, const value_type& __x);#ifdef __GXX_EXPERIMENTAL_CXX0X__      /**       *  @brief  Inserts given rvalue into %list before specified iterator.       *  @param  position  An iterator into the %list.       *  @param  x  Data to be inserted.       *  @return  An iterator that points to the inserted data.       *       *  This function will insert a copy of the given rvalue before       *  the specified location.  Due to the nature of a %list this       *  operation can be done in constant time, and does not       *  invalidate iterators and references.        */      iterator      insert(iterator __position, value_type&& __x)      { return emplace(__position, std::move(__x)); }      /**       *  @brief  Inserts the contents of an initializer_list into %list       *          before specified iterator.       *  @param  p  An iterator into the %list.       *  @param  l  An initializer_list of value_type.       *       *  This function will insert copies of the data in the       *  initializer_list @a l into the %list before the location       *  specified by @a p.       *       *  This operation is linear in the number of elements inserted and       *  does not invalidate iterators and references.       */      void      insert(iterator __p, initializer_list<value_type> __l)      { this->insert(__p, __l.begin(), __l.end()); }#endif      /**       *  @brief  Inserts a number of copies of given data into the %list.       *  @param  position  An iterator into the %list.       *  @param  n  Number of elements to be inserted.       *  @param  x  Data to be inserted.       *       *  This function will insert a specified number of copies of the       *  given data before the location specified by @a position.       *       *  This operation is linear in the number of elements inserted and       *  does not invalidate iterators and references.       */      void      insert(iterator __position, size_type __n, const value_type& __x)      {  list __tmp(__n, __x, _M_get_Node_allocator());splice(__position, __tmp);      }      /**       *  @brief  Inserts a range into the %list.       *  @param  position  An iterator into the %list.       *  @param  first  An input iterator.       *  @param  last   An input iterator.       *       *  This function will insert copies of the data in the range [@a       *  first,@a last) into the %list before the location specified by       *  @a position.       *       *  This operation is linear in the number of elements inserted and       *  does not invalidate iterators and references.       */      template<typename _InputIterator>        void        insert(iterator __position, _InputIterator __first,       _InputIterator __last)        {  list __tmp(__first, __last, _M_get_Node_allocator());  splice(__position, __tmp);}      /**       *  @brief  Remove element at given position.       *  @param  position  Iterator pointing to element to be erased.       *  @return  An iterator pointing to the next element (or end()).       *       *  This function will erase the element at the given position and thus       *  shorten the %list by one.       *       *  Due to the nature of a %list this operation can be done in       *  constant time, and only invalidates iterators/references to       *  the element being removed.  The user is also cautioned that       *  this function only erases the element, and that if the element       *  is itself a pointer, the pointed-to memory is not touched in       *  any way.  Managing the pointer is the user's responsibility.       */      iterator      erase(iterator __position);      /**       *  @brief  Remove a range of elements.       *  @param  first  Iterator pointing to the first element to be erased.       *  @param  last  Iterator pointing to one past the last element to be       *                erased.       *  @return  An iterator pointing to the element pointed to by @a last       *           prior to erasing (or end()).       *       *  This function will erase the elements in the range @a       *  [first,last) and shorten the %list accordingly.       *       *  This operation is linear time in the size of the range and only       *  invalidates iterators/references to the element being removed.       *  The user is also cautioned that this function only erases the       *  elements, and that if the elements themselves are pointers, the       *  pointed-to memory is not touched in any way.  Managing the pointer       *  is the user's responsibility.       */      iterator      erase(iterator __first, iterator __last)      {while (__first != __last)  __first = erase(__first);return __last;      }      /**       *  @brief  Swaps data with another %list.       *  @param  x  A %list of the same element and allocator types.       *       *  This exchanges the elements between two lists in constant       *  time.  Note that the global std::swap() function is       *  specialized such that std::swap(l1,l2) will feed to this       *  function.       */      void      swap(list& __x)      {_List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);// _GLIBCXX_RESOLVE_LIB_DEFECTS// 431. Swapping containers with unequal allocators.std::__alloc_swap<typename _Base::_Node_alloc_type>::  _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());      }      /**       *  Erases all the elements.  Note that this function only erases       *  the elements, and that if the elements themselves are       *  pointers, the pointed-to memory is not touched in any way.       *  Managing the pointer is the user's responsibility.       */      void      clear()      {        _Base::_M_clear();        _Base::_M_init();      }      // [23.2.2.4] list operations      /**       *  @brief  Insert contents of another %list.       *  @param  position  Iterator referencing the element to insert before.       *  @param  x  Source list.       *       *  The elements of @a x are inserted in constant time in front of       *  the element referenced by @a position.  @a x becomes an empty       *  list.       *       *  Requires this != @a x.       */      void#ifdef __GXX_EXPERIMENTAL_CXX0X__      splice(iterator __position, list&& __x)#else      splice(iterator __position, list& __x)#endif      {if (!__x.empty())  {    _M_check_equal_allocators(__x);    this->_M_transfer(__position, __x.begin(), __x.end());  }      }#ifdef __GXX_EXPERIMENTAL_CXX0X__      void      splice(iterator __position, list& __x)      { splice(__position, std::move(__x)); }#endif      /**       *  @brief  Insert element from another %list.       *  @param  position  Iterator referencing the element to insert before.       *  @param  x  Source list.       *  @param  i  Iterator referencing the element to move.       *       *  Removes the element in list @a x referenced by @a i and       *  inserts it into the current list before @a position.       */      void#ifdef __GXX_EXPERIMENTAL_CXX0X__      splice(iterator __position, list&& __x, iterator __i)#else      splice(iterator __position, list& __x, iterator __i)#endif      {iterator __j = __i;++__j;if (__position == __i || __position == __j)  return;if (this != &__x)  _M_check_equal_allocators(__x);this->_M_transfer(__position, __i, __j);      }#ifdef __GXX_EXPERIMENTAL_CXX0X__      void      splice(iterator __position, list& __x, iterator __i)      { splice(__position, std::move(__x), __i); }#endif      /**       *  @brief  Insert range from another %list.       *  @param  position  Iterator referencing the element to insert before.       *  @param  x  Source list.       *  @param  first  Iterator referencing the start of range in x.       *  @param  last  Iterator referencing the end of range in x.       *       *  Removes elements in the range [first,last) and inserts them       *  before @a position in constant time.       *       *  Undefined if @a position is in [first,last).       */      void#ifdef __GXX_EXPERIMENTAL_CXX0X__      splice(iterator __position, list&& __x, iterator __first,     iterator __last)#else      splice(iterator __position, list& __x, iterator __first,     iterator __last)#endif      {if (__first != __last)  {    if (this != &__x)      _M_check_equal_allocators(__x);    this->_M_transfer(__position, __first, __last);  }      }#ifdef __GXX_EXPERIMENTAL_CXX0X__      void      splice(iterator __position, list& __x, iterator __first, iterator __last)      { splice(__position, std::move(__x), __first, __last); }#endif      /**       *  @brief  Remove all elements equal to value.       *  @param  value  The value to remove.       *       *  Removes every element in the list equal to @a value.       *  Remaining elements stay in list order.  Note that this       *  function only erases the elements, and that if the elements       *  themselves are pointers, the pointed-to memory is not       *  touched in any way.  Managing the pointer is the user's       *  responsibility.       */      void      remove(const _Tp& __value);      /**       *  @brief  Remove all elements satisfying a predicate.       *  @param  Predicate  Unary predicate function or object.       *       *  Removes every element in the list for which the predicate       *  returns true.  Remaining elements stay in list order.  Note       *  that this function only erases the elements, and that if the       *  elements themselves are pointers, the pointed-to memory is       *  not touched in any way.  Managing the pointer is the user's       *  responsibility.       */      template<typename _Predicate>        void        remove_if(_Predicate);      /**       *  @brief  Remove consecutive duplicate elements.       *       *  For each consecutive set of elements with the same value,       *  remove all but the first one.  Remaining elements stay in       *  list order.  Note that this function only erases the       *  elements, and that if the elements themselves are pointers,       *  the pointed-to memory is not touched in any way.  Managing       *  the pointer is the user's responsibility.       */      void      unique();      /**       *  @brief  Remove consecutive elements satisfying a predicate.       *  @param  BinaryPredicate  Binary predicate function or object.       *       *  For each consecutive set of elements [first,last) that       *  satisfy predicate(first,i) where i is an iterator in       *  [first,last), remove all but the first one.  Remaining       *  elements stay in list order.  Note that this function only       *  erases the elements, and that if the elements themselves are       *  pointers, the pointed-to memory is not touched in any way.       *  Managing the pointer is the user's responsibility.       */      template<typename _BinaryPredicate>        void        unique(_BinaryPredicate);      /**       *  @brief  Merge sorted lists.       *  @param  x  Sorted list to merge.       *       *  Assumes that both @a x and this list are sorted according to       *  operator<().  Merges elements of @a x into this list in       *  sorted order, leaving @a x empty when complete.  Elements in       *  this list precede elements in @a x that are equal.       */#ifdef __GXX_EXPERIMENTAL_CXX0X__      void      merge(list&& __x);      void      merge(list& __x)      { merge(std::move(__x)); }#else      void      merge(list& __x);#endif      /**       *  @brief  Merge sorted lists according to comparison function.       *  @param  x  Sorted list to merge.       *  @param StrictWeakOrdering Comparison function defining       *  sort order.       *       *  Assumes that both @a x and this list are sorted according to       *  StrictWeakOrdering.  Merges elements of @a x into this list       *  in sorted order, leaving @a x empty when complete.  Elements       *  in this list precede elements in @a x that are equivalent       *  according to StrictWeakOrdering().       */#ifdef __GXX_EXPERIMENTAL_CXX0X__      template<typename _StrictWeakOrdering>        void        merge(list&&, _StrictWeakOrdering);      template<typename _StrictWeakOrdering>        void        merge(list& __x, _StrictWeakOrdering __comp)        { merge(std::move(__x), __comp); }#else      template<typename _StrictWeakOrdering>        void        merge(list&, _StrictWeakOrdering);#endif      /**       *  @brief  Reverse the elements in list.       *       *  Reverse the order of elements in the list in linear time.       */      void      reverse()      { this->_M_impl._M_node._M_reverse(); }      /**       *  @brief  Sort the elements.       *       *  Sorts the elements of this list in NlogN time.  Equivalent       *  elements remain in list order.       */      void      sort();      /**       *  @brief  Sort the elements according to comparison function.       *       *  Sorts the elements of this list in NlogN time.  Equivalent       *  elements remain in list order.       */      template<typename _StrictWeakOrdering>        void        sort(_StrictWeakOrdering);    protected:      // Internal constructor functions follow.      // Called by the range constructor to implement [23.1.1]/9      // _GLIBCXX_RESOLVE_LIB_DEFECTS      // 438. Ambiguity in the "do the right thing" clause      template<typename _Integer>        void        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)        { _M_fill_initialize(static_cast<size_type>(__n), __x); }      // Called by the range constructor to implement [23.1.1]/9      template<typename _InputIterator>        void        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,       __false_type)        {  for (; __first != __last; ++__first)    push_back(*__first);}      // Called by list(n,v,a), and the range constructor when it turns out      // to be the same thing.      void      _M_fill_initialize(size_type __n, const value_type& __x)      {for (; __n > 0; --__n)  push_back(__x);      }      // Internal assign functions follow.      // Called by the range assign to implement [23.1.1]/9      // _GLIBCXX_RESOLVE_LIB_DEFECTS      // 438. Ambiguity in the "do the right thing" clause      template<typename _Integer>        void        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)        { _M_fill_assign(__n, __val); }      // Called by the range assign to implement [23.1.1]/9      template<typename _InputIterator>        void        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,   __false_type);      // Called by assign(n,t), and the range assign when it turns out      // to be the same thing.      void      _M_fill_assign(size_type __n, const value_type& __val);      // Moves the elements from [first,last) before position.      void      _M_transfer(iterator __position, iterator __first, iterator __last)      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }      // Inserts new element at position given and with value given.#ifndef __GXX_EXPERIMENTAL_CXX0X__      void      _M_insert(iterator __position, const value_type& __x)      {        _Node* __tmp = _M_create_node(__x);        __tmp->_M_hook(__position._M_node);      }#else     template<typename... _Args>       void       _M_insert(iterator __position, _Args&&... __args)       { _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); __tmp->_M_hook(__position._M_node);       }#endif      // Erases element at position given.      void      _M_erase(iterator __position)      {        __position._M_node->_M_unhook();        _Node* __n = static_cast<_Node*>(__position._M_node);#ifdef __GXX_EXPERIMENTAL_CXX0X__        _M_get_Node_allocator().destroy(__n);#else_M_get_Tp_allocator().destroy(&__n->_M_data);#endif        _M_put_node(__n);      }      // To implement the splice (and merge) bits of N1599.      void      _M_check_equal_allocators(list& __x)      {if (std::__alloc_neq<typename _Base::_Node_alloc_type>::    _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))  __throw_runtime_error(__N("list::_M_check_equal_allocators"));      }    };

STL_list test

//=====================================================// list// comparison operators// list::list// list::~list// member functions:// list::assign// list::back @return value_of_listback// list::begin @return iterator_of_list::begin// list::clear @clear list// list::empty @if list is empty then return true// list::end @return iterator_of_list::end// list::erase @delete erase(iterator),erase(iterator_first,iterator_end)// list::front @return front_of_list_value// list::get_allocator// list::insert @insert(@param1_iterator,@param2_value)// list::max_size// list::merge// list::operator=// list::pop_back @delete tail of list// list::pop_front @delete front of list// list::push_back @对list,back插入value// list::push_front @对ist,fornt插入value// list::rbegin// list::remove// list::remove_if// list::rend// list::resize// list::reverse// list::size @return list_size// list::sort @对list排序// list::splice// list::swap @swap两个list// list::unique @对list去重复// Description ://=======================================================#include <iostream>#include <list>#include <cstring>#include <cstdio>#include <vector>#include <cmath>using namespace std;int main() {list<int>mylist;list<int>::iterator it;for(int i=1;i<5;i++) mylist.push_back(i);//1 2 3 4 5//  ^it=mylist.begin();it++;// it points now to number 2cout<<"iterator it now = "<<*it<<endl;mylist.insert(it,999);cout<<"after insert it now = "<<*it<<endl;// "it" still points to number 2mylist.insert(it,1000);mylist.insert(it,1000);it=mylist.begin();//mylist.push_front(0);//mylist.pop_back();//mylist.pop_front();while(it!=mylist.end())cout<<" "<<*it++;puts("");mylist.sort();//sort listcout<<"after use list::sort() sort list "<<endl;it=mylist.begin();while(it!=mylist.end())cout<<" "<<*it++;puts("");mylist.unique();cout<<"after use list::unique()"<<endl;mylist.erase(mylist.begin());//deleteit=mylist.begin();while(it!=mylist.end())cout<<" "<<*it++;puts("");cout<<"mylist.back_value = "<<mylist.back()<<endl;mylist.clear();if(mylist.empty()) cout<<"list is empty"<<endl;return 0;}//iterator it now = 2//after insert it now = 2// 1 999 1000 1000 2 3 4//after use list::sort() sort list// 1 2 3 4 999 1000 1000//after use list::unique()// 2 3 4 999 1000//mylist.back_value = 1000//list is empty