Standard C++ Library Reference ISO/IEC (VERSION3)

template<class Pr2>
void unique(Pr2 pred);
void merge(list& right);
template<class Pr3>
void merge(list& right, Pr3 pred);
void sort();
template<class Pr3>
void sort(Pr3 pred);
void reverse();
};
The template class describes an object that controls a varying-length sequence of elements of
type Ty. The sequence is stored as a bidirectional linked list of elements, each containing a
member of type Ty.
The object allocates and frees storage for the sequence it controls through a stored allocator
object of class Alloc. Such an allocator object must have the same external interface as an
object of template class allocator. Note that the stored allocator object is not copied when
the container object is assigned.
List reallocation occurs when a member function must insert or erase elements of the
controlled sequence. In all such cases, only iterators or references that point at erased portions
of the controlled sequence become invalid.
All additions to the controlled sequence occur as if by calls to insert, which is the only
member function that calls the constructor Ty(const Ty&). If such an expression throws an
exception, the container object inserts no new elements and rethrows the exception. Thus, an
object of template class list is left in a known state when such exceptions occur.
list::allocator_type
typedef Alloc allocator_type;
The type is a synonym for the template parameter Alloc.
list::assign
template<class InIt>
void assign(InIt first, InIt last);
void assign(size_type count, const Ty& val);
If InIt is an integer type, the first member function behaves the same as
assign((size_type)first, (Ty)last). Otherwise, the first member function
replaces the sequence controlled by *this with the sequence [first, last), which must
not overlap the initial controlled sequence. The second member function replaces the sequence
controlled by *this with a repetition of count elements of value val.