Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

list Class Template Reference

#include <stl_list.h>

Collaboration diagram for list:

Collaboration graph
[legend]
List of all members.

Public Types

typedef T value_type
typedef value_type * pointer
typedef const value_type * const_pointer
typedef value_type & reference
typedef const value_type & const_reference
typedef list_node * link_type
typedef size_t size_type
typedef ptrdiff_t difference_type
typedef __list_iterator< T,
T &, T * > 		iterator
typedef __list_iterator< T,
const T &, const T * > 		const_iterator
typedef reverse_bidirectional_iterator<
const_iterator, value_type,
const_reference, difference_type > 		const_reverse_iterator
typedef reverse_bidirectional_iterator<
iterator, value_type, reference,
difference_type > 		reverse_iterator

Public Methods

 list ()
iterator begin ()
const_iterator begin () const
iterator end ()
const_iterator end () const
reverse_iterator rbegin ()
const_reverse_iterator rbegin () const
reverse_iterator rend ()
const_reverse_iterator rend () const
bool empty () const
size_type size () const
size_type max_size () const
reference front ()
const_reference front () const
reference back ()
const_reference back () const
void swap (list< T, Alloc > &x)
iterator insert (iterator position, const T &x)
iterator insert (iterator position)
void insert (iterator position, const T *first, const T *last)
void insert (iterator position, const_iterator first, const_iterator last)
void insert (iterator pos, size_type n, const T &x)
void insert (iterator pos, int n, const T &x)
void insert (iterator pos, long n, const T &x)
void push_front (const T &x)
void push_back (const T &x)
iterator erase (iterator position)
iterator erase (iterator first, iterator last)
void resize (size_type new_size, const T &x)
void resize (size_type new_size)
void clear ()
void pop_front ()
void pop_back ()
 list (size_type n, const T &value)
 list (int n, const T &value)
 list (long n, const T &value)
 list (size_type n)
 list (const T *first, const T *last)
 list (const_iterator first, const_iterator last)
 list (const list< T, Alloc > &x)
 ~list ()
list< T, Alloc > & operator= (const list< T, Alloc > &x)
void splice (iterator position, list &x)
void splice (iterator position, list &, iterator i)
void splice (iterator position, list &, iterator first, iterator last)
void remove (const T &value)
void unique ()
void merge (list &x)
void reverse ()
void sort ()

Protected Types

typedef void * void_pointer
typedef __list_node< T > list_node
typedef simple_alloc< list_node,
Alloc > 		list_node_allocator

Protected Methods

link_type get_node ()
void put_node (link_type p)
link_type create_node (const T &x)
void destroy_node (link_type p)
void empty_initialize ()
void fill_initialize (size_type n, const T &value)
void range_initialize (const T *first, const T *last)
void range_initialize (const_iterator first, const_iterator last)
void transfer (iterator position, iterator first, iterator last)

Protected Attributes

link_type node

Friends

bool operator==__STL_NULL_TMPL_ARGS (const list &x, const list &y)

template<class T, class Alloc = alloc>
class list< T, Alloc >

Member Typedef Documentation

template<class T, class Alloc = alloc>
typedef __list_iterator<T, const T&, const T*> list::const_iterator
 

Definition at line 136 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef const value_type* list::const_pointer
 

Definition at line 127 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef const value_type& list::const_reference
 

Definition at line 129 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef reverse_bidirectional_iterator<const_iterator, value_type, const_reference, difference_type> list::const_reverse_iterator
 

Definition at line 144 of file stl_list.h.

Referenced by rbegin, and rend.

template<class T, class Alloc = alloc>
typedef ptrdiff_t list::difference_type
 

Definition at line 132 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef __list_iterator<T, T&, T*> list::iterator
 

Definition at line 135 of file stl_list.h.

Referenced by erase.

template<class T, class Alloc = alloc>
typedef list_node* list::link_type
 

Definition at line 130 of file stl_list.h.

Referenced by erase, insert, reverse, sort, and transfer.

template<class T, class Alloc = alloc>
typedef __list_node<T> list::list_node [protected]
 

Definition at line 122 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef simple_alloc<list_node, Alloc> list::list_node_allocator [protected]
 

Definition at line 123 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef value_type* list::pointer
 

Definition at line 126 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef value_type& list::reference
 

Definition at line 128 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef reverse_bidirectional_iterator<iterator, value_type, reference, difference_type> list::reverse_iterator
 

Definition at line 147 of file stl_list.h.

Referenced by rbegin, and rend.

template<class T, class Alloc = alloc>
typedef size_t list::size_type
 

Definition at line 131 of file stl_list.h.

Referenced by fill_initialize, insert, list, max_size, resize, and size.

template<class T, class Alloc = alloc>
typedef T list::value_type
 

Definition at line 125 of file stl_list.h.

template<class T, class Alloc = alloc>
typedef void* list::void_pointer [protected]
 

Definition at line 121 of file stl_list.h.

Constructor & Destructor Documentation

template<class T, class Alloc = alloc>
list< T, Alloc >::list (    )  [inline]
 

Definition at line 212 of file stl_list.h.

References empty_initialize. 

00212 { empty_initialize(); }

template<class T, class Alloc = alloc>
list< T, Alloc >::list (  size_type    n,
const T &    value
)  [inline]
 

Definition at line 283 of file stl_list.h.

References fill_initialize, and size_type. 

00283 { fill_initialize(n, value); }

template<class T, class Alloc = alloc>
list< T, Alloc >::list (  int    n,
const T &    value
)  [inline]
 

Definition at line 284 of file stl_list.h.

References fill_initialize. 

00284 { fill_initialize(n, value); }

template<class T, class Alloc = alloc>
list< T, Alloc >::list (  long    n,
const T &    value
)  [inline]
 

Definition at line 285 of file stl_list.h.

References fill_initialize. 

00285 { fill_initialize(n, value); }

template<class T, class Alloc = alloc>
list< T, Alloc >::list (  size_type    n )  [inline, explicit]
 

Definition at line 286 of file stl_list.h.

References fill_initialize, and size_type. 

00286 { fill_initialize(n, T()); }

template<class T, class Alloc = alloc>
list< T, Alloc >::list (  const T *    first,
const T *    last
)  [inline]
 

Definition at line 295 of file stl_list.h.

References range_initialize. 

00295 { range_initialize(first, last); }

template<class T, class Alloc = alloc>
list< T, Alloc >::list (  const_iterator    first,
const_iterator    last
)  [inline]
 

Definition at line 296 of file stl_list.h.

References range_initialize. 

00296                                                   {
00297     range_initialize(first, last);
00298   }

template<class T, class Alloc = alloc>
list< T, Alloc >::list (  const list< T, Alloc > &    x )  [inline]
 

Definition at line 300 of file stl_list.h.

References begin, end, and range_initialize. 

00300                                 {
00301     range_initialize(x.begin(), x.end());
00302   }

template<class T, class Alloc = alloc>
list< T, Alloc >::~list (    )  [inline]
 

Definition at line 303 of file stl_list.h.

References clear, and put_node. 

00303           {
00304     clear();
00305     put_node(node);
00306   }

Member Function Documentation

template<class T, class Alloc = alloc>
const_reference list< T, Alloc >::back (    )  const [inline]
 

Definition at line 236 of file stl_list.h.

References end. 

00236 { return *(--end()); }

template<class T, class Alloc = alloc>
reference list< T, Alloc >::back (    )  [inline]
 

Definition at line 235 of file stl_list.h.

References end. 

00235 { return *(--end()); }

template<class T, class Alloc = alloc>
const_iterator list< T, Alloc >::begin (    )  const [inline]
 

Definition at line 215 of file stl_list.h. 

00215 { return (link_type)((*node).next); }

template<class T, class Alloc = alloc>
iterator list< T, Alloc >::begin (    )  [inline]
 

Definition at line 214 of file stl_list.h.

Referenced by fill_initialize, front, list, merge, operator=, pop_front, push_front, range_initialize, remove, rend, resize, reverse, size, sort, splice, and unique. 

00214 { return (link_type)((*node).next); }

template<class T, class Alloc>
void list< T, Alloc >::clear (    ) 
 

Definition at line 433 of file stl_list.h.

References destroy_node, __list_node::next, node, and __list_node::prev.

Referenced by fill_initialize, range_initialize, and ~list. 

00434 {
00435   link_type cur = (link_type) node->next;
00436   while (cur != node) {
00437     link_type tmp = cur;
00438     cur = (link_type) cur->next;
00439     destroy_node(tmp);
00440   }
00441   node->next = node;
00442   node->prev = node;
00443 }

template<class T, class Alloc = alloc>
link_type list< T, Alloc >::create_node (  const T &    x )  [inline, protected]
 

Definition at line 154 of file stl_list.h.

References __STL_TRY, __STL_UNWIND, construct, __list_node::data, get_node, and put_node.

Referenced by insert. 

00154                                     {
00155     link_type p = get_node();
00156     __STL_TRY {
00157       construct(&p->data, x);
00158     }
00159     __STL_UNWIND(put_node(p));
00160     return p;
00161   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::destroy_node (  link_type    p )  [inline, protected]
 

Definition at line 162 of file stl_list.h.

References __list_node::data, destroy, and put_node.

Referenced by clear, and erase. 

00162                                  {
00163     destroy(&p->data);
00164     put_node(p);
00165   }

template<class T, class Alloc = alloc>
bool list< T, Alloc >::empty (    )  const [inline]
 

Definition at line 226 of file stl_list.h.

References __list_node::next.

Referenced by sort, and splice. 

00226 { return node->next == node; }

template<class T, class Alloc = alloc>
void list< T, Alloc >::empty_initialize (    )  [inline, protected]
 

Definition at line 168 of file stl_list.h.

References get_node, __list_node::next, node, and __list_node::prev.

Referenced by fill_initialize, list, and range_initialize. 

00168                           { 
00169     node = get_node();
00170     node->next = node;
00171     node->prev = node;
00172   }

template<class T, class Alloc = alloc>
const_iterator list< T, Alloc >::end (    )  const [inline]
 

Definition at line 217 of file stl_list.h. 

00217 { return node; }

template<class T, class Alloc = alloc>
iterator list< T, Alloc >::end (    )  [inline]
 

Definition at line 216 of file stl_list.h.

Referenced by back, list, merge, operator=, pop_back, push_back, rbegin, remove, resize, reverse, size, splice, and unique. 

00216 { return node; }

template<class T, class Alloc>
list< T, Alloc >::iterator list< T, Alloc >::erase (  iterator    first,
iterator    last
) 
 

Definition at line 414 of file stl_list.h.

References erase. 

00414                                                                          {
00415   while (first != last) erase(first++);
00416   return last;
00417 }

template<class T, class Alloc = alloc>
iterator list< T, Alloc >::erase (  iterator    position )  [inline]
 

Definition at line 265 of file stl_list.h.

References destroy_node, iterator, link_type, __list_node::next, __list_iterator::node, and __list_node::prev.

Referenced by erase, operator=, pop_back, pop_front, remove, resize, and unique. 

00265                                     {
00266     link_type next_node = link_type(position.node->next);
00267     link_type prev_node = link_type(position.node->prev);
00268     prev_node->next = next_node;
00269     next_node->prev = prev_node;
00270     destroy_node(position.node);
00271     return iterator(next_node);
00272   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::fill_initialize (  size_type    n,
const T &    value
)  [inline, protected]
 

Definition at line 174 of file stl_list.h.

References __STL_TRY, __STL_UNWIND, begin, clear, empty_initialize, insert, node, put_node, and size_type.

Referenced by list. 

00174                                                     {
00175     empty_initialize();
00176     __STL_TRY {
00177       insert(begin(), n, value);
00178     }
00179     __STL_UNWIND(clear(); put_node(node));
00180   }

template<class T, class Alloc = alloc>
const_reference list< T, Alloc >::front (    )  const [inline]
 

Definition at line 234 of file stl_list.h.

References begin. 

00234 { return *begin(); }

template<class T, class Alloc = alloc>
reference list< T, Alloc >::front (    )  [inline]
 

Definition at line 233 of file stl_list.h.

References begin. 

00233 { return *begin(); }

template<class T, class Alloc = alloc>
link_type list< T, Alloc >::get_node (    )  [inline, protected]
 

Definition at line 151 of file stl_list.h.

Referenced by create_node, and empty_initialize. 

00151 { return list_node_allocator::allocate(); }

template<class T, class Alloc = alloc>
void list< T, Alloc >::insert (  iterator    pos,
long    n,
const T &    x
)  [inline]
 

Definition at line 259 of file stl_list.h.

References insert, and size_type. 

00259                                                 {
00260     insert(pos, (size_type)n, x);
00261   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::insert (  iterator    pos,
int    n,
const T &    x
)  [inline]
 

Definition at line 256 of file stl_list.h.

References insert, and size_type. 

00256                                                {
00257     insert(pos, (size_type)n, x);
00258   }

template<class T, class Alloc>
void list< T, Alloc >::insert (  iterator    pos,
size_type    n,
const T &    x
) 
 

Definition at line 408 of file stl_list.h.

References insert. 

00408                                                                       {
00409   for ( ; n > 0; --n)
00410     insert(position, x);
00411 }

template<class T, class Alloc>
void list< T, Alloc >::insert (  iterator    position,
const_iterator    first,
const_iterator    last
) 
 

Definition at line 399 of file stl_list.h.

References insert. 

00400                                                                        {
00401   for ( ; first != last; ++first)
00402     insert(position, *first);
00403 }

template<class T, class Alloc>
void list< T, Alloc >::insert (  iterator    position,
const T *    first,
const T *    last
) 
 

Definition at line 393 of file stl_list.h.

References insert. 

00393                                                                             {
00394   for ( ; first != last; ++first)
00395     insert(position, *first);
00396 }

template<class T, class Alloc = alloc>
iterator list< T, Alloc >::insert (  iterator    position )  [inline]
 

Definition at line 246 of file stl_list.h.

References insert. 

00246 { return insert(position, T()); }

template<class T, class Alloc = alloc>
iterator list< T, Alloc >::insert (  iterator    position,
const T &    x
)  [inline]
 

Definition at line 238 of file stl_list.h.

References create_node, link_type, __list_node::next, __list_iterator::node, and __list_node::prev.

Referenced by fill_initialize, insert, operator=, push_back, push_front, range_initialize, and resize. 

00238                                                  {
00239     link_type tmp = create_node(x);
00240     tmp->next = position.node;
00241     tmp->prev = position.node->prev;
00242     (link_type(position.node->prev))->next = tmp;
00243     position.node->prev = tmp;
00244     return tmp;
00245   }

template<class T, class Alloc = alloc>
size_type list< T, Alloc >::max_size (    )  const [inline]
 

Definition at line 232 of file stl_list.h.

References size_type. 

00232 { return size_type(-1); }

template<class T, class Alloc>
void list< T, Alloc >::merge (  list< T, Alloc > &    x ) 
 

Definition at line 489 of file stl_list.h.

References begin, end, and transfer.

Referenced by sort. 

00489                                             {
00490   iterator first1 = begin();
00491   iterator last1 = end();
00492   iterator first2 = x.begin();
00493   iterator last2 = x.end();
00494   while (first1 != last1 && first2 != last2)
00495     if (*first2 < *first1) {
00496       iterator next = first2;
00497       transfer(first1, first2, ++next);
00498       first2 = next;
00499     }
00500     else
00501       ++first1;
00502   if (first2 != last2) transfer(last1, first2, last2);
00503 }

template<class T, class Alloc>
list< T, Alloc > & list< T, Alloc >::operator= (  const list< T, Alloc > &    x ) 
 

Definition at line 446 of file stl_list.h.

References begin, end, erase, and insert. 

00446                                                                  {
00447   if (this != &x) {
00448     iterator first1 = begin();
00449     iterator last1 = end();
00450     const_iterator first2 = x.begin();
00451     const_iterator last2 = x.end();
00452     while (first1 != last1 && first2 != last2) *first1++ = *first2++;
00453     if (first2 == last2)
00454       erase(first1, last1);
00455     else
00456       insert(last1, first2, last2);
00457   }
00458   return *this;
00459 }

template<class T, class Alloc = alloc>
void list< T, Alloc >::pop_back (    )  [inline]
 

Definition at line 279 of file stl_list.h.

References end, and erase. 

00279                   { 
00280     iterator tmp = end();
00281     erase(--tmp);
00282   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::pop_front (    )  [inline]
 

Definition at line 278 of file stl_list.h.

References begin, and erase. 

00278 { erase(begin()); }

template<class T, class Alloc = alloc>
void list< T, Alloc >::push_back (  const T &    x )  [inline]
 

Definition at line 264 of file stl_list.h.

References end, and insert. 

00264 { insert(end(), x); }

template<class T, class Alloc = alloc>
void list< T, Alloc >::push_front (  const T &    x )  [inline]
 

Definition at line 263 of file stl_list.h.

References begin, and insert. 

00263 { insert(begin(), x); }

template<class T, class Alloc = alloc>
void list< T, Alloc >::put_node (  link_type    p )  [inline, protected]
 

Definition at line 152 of file stl_list.h.

Referenced by create_node, destroy_node, fill_initialize, range_initialize, and ~list. 

00152 { list_node_allocator::deallocate(p); }

template<class T, class Alloc = alloc>
void list< T, Alloc >::range_initialize (  const_iterator    first,
const_iterator    last
)  [inline, protected]
 

Definition at line 199 of file stl_list.h.

References __STL_TRY, __STL_UNWIND, begin, clear, empty_initialize, insert, node, and put_node. 

00199                                                                    {
00200     empty_initialize();
00201     __STL_TRY {
00202       insert(begin(), first, last);
00203     }
00204     __STL_UNWIND(clear(); put_node(node));
00205   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::range_initialize (  const T *    first,
const T *    last
)  [inline, protected]
 

Definition at line 192 of file stl_list.h.

References __STL_TRY, __STL_UNWIND, begin, clear, empty_initialize, insert, node, and put_node.

Referenced by list. 

00192                                                        {
00193     empty_initialize();
00194     __STL_TRY {
00195       insert(begin(), first, last);
00196     }
00197     __STL_UNWIND(clear(); put_node(node));
00198   }

template<class T, class Alloc = alloc>
const_reverse_iterator list< T, Alloc >::rbegin (    )  const [inline]
 

Definition at line 219 of file stl_list.h.

References const_reverse_iterator, and end. 

00219                                         { 
00220     return const_reverse_iterator(end()); 
00221   }

template<class T, class Alloc = alloc>
reverse_iterator list< T, Alloc >::rbegin (    )  [inline]
 

Definition at line 218 of file stl_list.h.

References end, and reverse_iterator. 

00218 { return reverse_iterator(end()); }

template<class T, class Alloc>
void list< T, Alloc >::remove (  const T &    value ) 
 

Definition at line 462 of file stl_list.h.

References begin, end, and erase. 

00462                                           {
00463   iterator first = begin();
00464   iterator last = end();
00465   while (first != last) {
00466     iterator next = first;
00467     ++next;
00468     if (*first == value) erase(first);
00469     first = next;
00470   }
00471 }

template<class T, class Alloc = alloc>
const_reverse_iterator list< T, Alloc >::rend (    )  const [inline]
 

Definition at line 223 of file stl_list.h.

References begin, and const_reverse_iterator. 

00223                                       { 
00224     return const_reverse_iterator(begin());
00225   }

template<class T, class Alloc = alloc>
reverse_iterator list< T, Alloc >::rend (    )  [inline]
 

Definition at line 222 of file stl_list.h.

References begin, and reverse_iterator. 

00222 { return reverse_iterator(begin()); }

template<class T, class Alloc = alloc>
void list< T, Alloc >::resize (  size_type    new_size )  [inline]
 

Definition at line 275 of file stl_list.h.

References resize, and size_type. 

00275 { resize(new_size, T()); }

template<class T, class Alloc>
void list< T, Alloc >::resize (  size_type    new_size,
const T &    x
) 
 

Definition at line 420 of file stl_list.h.

References begin, end, erase, insert, and size_type.

Referenced by resize. 

00421 {
00422   iterator i = begin();
00423   size_type len = 0;
00424   for ( ; i != end() && len < new_size; ++i, ++len)
00425     ;
00426   if (len == new_size)
00427     erase(i, end());
00428   else                          // i == end()
00429     insert(end(), new_size - len, x);
00430 }

template<class T, class Alloc>
void list< T, Alloc >::reverse (    ) 
 

Definition at line 506 of file stl_list.h.

References begin, end, link_type, __list_node::next, node, and transfer. 

00506                              {
00507   if (node->next == node || link_type(node->next)->next == node) return;
00508   iterator first = begin();
00509   ++first;
00510   while (first != end()) {
00511     iterator old = first;
00512     ++first;
00513     transfer(begin(), old, first);
00514   }
00515 }

template<class T, class Alloc = alloc>
size_type list< T, Alloc >::size (    )  const [inline]
 

Definition at line 227 of file stl_list.h.

References begin, distance, end, and size_type. 

00227                          {
00228     size_type result = 0;
00229     distance(begin(), end(), result);
00230     return result;
00231   }

template<class T, class Alloc>
void list< T, Alloc >::sort (    ) 
 

Definition at line 518 of file stl_list.h.

References begin, empty, fill, link_type, merge, __list_node::next, node, splice, and swap. 

00518                           {
00519   if (node->next == node || link_type(node->next)->next == node) return;
00520   list<T, Alloc> carry;
00521   list<T, Alloc> counter[64];
00522   int fill = 0;
00523   while (!empty()) {
00524     carry.splice(carry.begin(), *this, begin());
00525     int i = 0;
00526     while(i < fill && !counter[i].empty()) {
00527       counter[i].merge(carry);
00528       carry.swap(counter[i++]);
00529     }
00530     carry.swap(counter[i]);         
00531     if (i == fill) ++fill;
00532   } 
00533 
00534   for (int i = 1; i < fill; ++i) counter[i].merge(counter[i-1]);
00535   swap(counter[fill-1]);
00536 }

template<class T, class Alloc = alloc>
void list< T, Alloc >::splice (  iterator    position,
list< T, Alloc > &   ,
iterator    first,
iterator    last
)  [inline]
 

Definition at line 333 of file stl_list.h.

References transfer. 

00333                                                                        {
00334     if (first != last) 
00335       transfer(position, first, last);
00336   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::splice (  iterator    position,
list< T, Alloc > &   ,
iterator    i
)  [inline]
 

Definition at line 327 of file stl_list.h.

References transfer. 

00327                                                     {
00328     iterator j = i;
00329     ++j;
00330     if (position == i || position == j) return;
00331     transfer(position, i, j);
00332   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::splice (  iterator    position,
list< T, Alloc > &    x
)  [inline]
 

Definition at line 323 of file stl_list.h.

References begin, empty, end, and transfer.

Referenced by sort. 

00323                                           {
00324     if (!x.empty()) 
00325       transfer(position, x.begin(), x.end());
00326   }

template<class T, class Alloc = alloc>
void list< T, Alloc >::swap (  list< T, Alloc > &    x )  [inline]
 

Definition at line 237 of file stl_list.h.

References node, and swap.

Referenced by sort. 

00237 { __STD::swap(node, x.node); }

template<class T, class Alloc = alloc>
void list< T, Alloc >::transfer (  iterator    position,
iterator    first,
iterator    last
)  [inline, protected]
 

Definition at line 310 of file stl_list.h.

References link_type, __list_node::next, and __list_iterator::node.

Referenced by merge, reverse, and splice. 

00310                                                                   {
00311     if (position != last) {
00312       (*(link_type((*last.node).prev))).next = position.node;
00313       (*(link_type((*first.node).prev))).next = last.node;
00314       (*(link_type((*position.node).prev))).next = first.node;  
00315       link_type tmp = link_type((*position.node).prev);
00316       (*position.node).prev = (*last.node).prev;
00317       (*last.node).prev = (*first.node).prev; 
00318       (*first.node).prev = tmp;
00319     }
00320   }

template<class T, class Alloc>
void list< T, Alloc >::unique (    ) 
 

Definition at line 474 of file stl_list.h.

References begin, end, and erase. 

00474                             {
00475   iterator first = begin();
00476   iterator last = end();
00477   if (first == last) return;
00478   iterator next = first;
00479   while (++next != last) {
00480     if (*first == *next)
00481       erase(next);
00482     else
00483       first = next;
00484     next = first;
00485   }
00486 }

Friends And Related Function Documentation

template<class T, class Alloc = alloc>
bool operator==__STL_NULL_TMPL_ARGS (  const list< T, Alloc > &    x,
const list< T, Alloc > &    y
)  [friend]
 

Member Data Documentation

template<class T, class Alloc = alloc>
link_type list::node [protected]
 

Definition at line 209 of file stl_list.h.

Referenced by clear, empty_initialize, fill_initialize, operator==, range_initialize, reverse, sort, and swap.

The documentation for this class was generated from the following file:
logo OpenMask

Documentation generated on Thu May 2 15:03:33 2002

Generated with doxygen 1.2.12 by Dimitri van Heesch ,   1997-2001