STL-顺序容器

1.容器创建

explicit vector ( const Allocator& = Allocator() );
explicit vector ( size_type n, const T& value= T(), const Allocator& = Allocator() );
template <class InputIterator> vector ( InputIterator first, InputIterator last, const Allocator& = Allocator() );
vector ( const vector<T,Allocator>& x ); //用另外一个容器创建

2.迭代器操作
*iter
iter->mem
++iter
iter++
--iter
iter--
iter1 == iter2
iter1 != iter2
--------------------------
iter + n                   //只有vector和deque支持算术运算和关系运算，list不支持
iter – n
iter1 += iter2
iter1 -= iter2
iter1 – iter2
iter1 > iter2
iter1 < iter2
iter1 <= iter2
iter1 >= iter2

3.内置类型
C<T>::size_type
C<T>::iterator
C<T>::const_iterator                //注意与const C<T>::iterator不同
C<T>::reverse_iterator
C<T>::const_reverse_iterator
C<T>::value_type
C<T>::reference                     //左值类型，即value_type&
C<T>::const_reference           //const value_type&

4.基本操作

Element access:

c[n]                                        //只适用于vector、deque容器
C<T>::value_type  c.at(n);      //只适用于vector、deque容器，防止越界
C<T>::value_type  c.front();
C<T>::value_type  c.back();

Modifiers:

void  c.push_back(const T& x);
void  c.push_front(const T& x);        //只适用list、deque

void  c.pop_back();
void  c.pop_front();          //只适用于list、deque容器

iterator insert ( iterator position, const T& x );
void insert ( iterator position, size_type n, const T& x );
template <class InputIterator> void insert ( iterator position, InputIterator first, InputIterator last );

iterator erase ( iterator position );
iterator erase ( iterator first, iterator last );

template <class InputIterator> void assign ( InputIterator first, InputIterator last );
void assign ( size_type n, const T& u );

void  c.clear();
void  c1.swap(c2);        //c1和c2类型必须相同，且迭代器不失效

Capacity:

C<T>::size_type  c.size();
C<T>::size_type  c.max_size();   //最多可容纳的元素，与类型有关，总存储空间固定
bool  c.empyt();
void  c.resize(n);
void  c.resize(n, t);                   //重调c的大小，新添加的元素值使用t值
void  c.reserve(n);
void  c.capacity();

5.list特有函数

 

void splice ( iterator position, list<T,Allocator>& x ); //将一个链表的内容移到另一个链表中
void splice ( iterator position, list<T,Allocator>& x, iterator it );
void splice ( iterator position, list<T,Allocator>& x, iterator first, iterator last );

e.g. 

list1为1,2,3,4. list2为10,20,30.

it=list1.begin();

list1.splice(it, list2); 后为list1为10,20,30,1,2,3,4. list2为空,lit仍指向1

list2.splice(list2.begin(), list1, list1.begin());后为list1为10,20,30,1,2,3,4. list2为1

 

void remove( const T& value ); //删除所有值为value的元素.

template <class Predicate>void remove_if ( Predicate pred );

void unique ( );
template <class BinaryPredicate>void unique ( BinaryPredicate binary_pred );

void merge ( list<T,Allocator>& x );
template <class Compare> void merge ( list<T,Allocator>& x, Compare comp );

void sort ( );
template <class Compare> void sort ( Compare comp );