c++标准库

标准库功能：

1. 提供了对一些语言特征的支持，例如，对于存储管理和运行时类型信息的支持。
2. 提供了有关实现所确定的语言方面的一些信息，例如最大的float值。
3. 提供了那些无法在每个系统上由语言本身做出最优实现的函数，如sqrt()和memmove()
4. 提供了一些非基本的功能，使程序员可以为可移植性而依靠它们，例如表，映射，排序函数和I/O流。
5. 提供了一个为扩展它所提供功能的基本框架。例如，使用户可以按照内部类型I/O的风格为用户定义类型提供I/O机制的规制和支持功能。
6. 为其他库提供一个公共的基础。

vector：

类型

template < class T, class A = allocator<T> > class std::vector {public:typedef T value_type;// 元素类型typedef A allocator_type;// 存储管理器类型typedef typename A::size_type size_type;typedef typename A::difference_type difference_type;typedef implementation_dependent1 iterator;// T*typedef implementation_dependent2 const_iterator;// const T*typedef std::reverse_iterator<iterator> reverse_iterator;typedef std::reverse_iterator<const_iterator> const_reverce_iterator;typedef typename A::pointer pointer;// 元素指针typedef typename A::const_pointer const_pointer;typedef typename A::reference reference;// 元素引用typedef typename A::const_reverce const_reference;}

size_type描述的是用做容器下标的类型，difference_type是求该容器的两个迭代器之差得到得到的结果类型。

template<class C>typename C::value_type sum( const C& c ) {typename C::value_type s = 0;typename C::const_iterator p = c.begin();while( p != c.end() ) {s += *p;++p;}return s;}

迭代器

template < class T, class A = allocator<T> > class std::vector {public: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;// 指向反向序列的过末端一个元素位置}

template<class C>typename C::iterator find_last( C& c, typename C::value_type v ) {typename C::reverse_iterator ri = find( c.rbegin(), c.rend(), v );if ( ri == c.rend() )return c.end();typename C::iterator i = ri.base();return --i;}

对于reverse_iterator，ri.base()返回一个iterator，指向ri所指之处后面的一个位置。请注意，C::reverse_iterator与C::iterator不是同一个类型。

元素访问

template < class T, class A = allocator<T> > class std::vector {public:reference operator[] ( size_type n );// 不带检查的访问const_reference operator[] ( size_type n ) const;reference at( size_type n );// 带检查的访问const_reference at( size_type n ) const;}

at()做范围检查时，如果下标越界则抛出out_of_range异常。front()返回对第一个元素的应用，而begin()返回的是到这个元素的迭代器。back()是返回最后一个元素，而end()则则指向最后一个元素的下一个位置。

构造函数

template < class T, class A = allocator<T> > class std::vector {public:explicit vector( const A& = A() );explicit vector( size_type n, const T& val = T(), const A& = A() );// n个val的副本template <class In> vector( In first, In last, const A& = A() );// In必须是输入迭代器，由[first : last[复制vector( const vector& x );~vector();vector& operator = ( const vector& x );template <class In> void assign( In first, In last );// In必须是输入迭代器，由[first : last[复制void assign( size_type n, const T& val );// n个val的副本}

堆栈操作

template < class T, class A = allocator<T> > class std::vector {public:void push_back( const T& x );// 在最后加入void pop_back();// 删除最后元素}

push_bak()将隐式地导致vector的size()的增长，所有vector不会上溢（只要还存在可以申请到的内存）。然而，vector确实可能下溢，下溢的效果是无定义的。pop_back()的最明显实现方式可能导致不属于vector的内存被复写。

void f( void ) {vector<int> v;v.pop_back();// 无定义效果：v的状态变成无定义v.push_back(7);// 无定义效果（因为v的状态无定义），可能极糟}

表操作

template < class T, class A = allocator<T> > class std::vector {public:iterator insert( iterator pos, const T& x );// 在pos前加入xvoid insert( iterator pos, size_type n, const T& x );// 在pos钱加入n个x的副本template<class In> void insert( iterator pos, In first, In last );// In必须是输入迭代器，插入一批来自序列的元素iterator erase( iterator pos );// 在pos删除元素iterator erase( iterator first, iterator last );// 删除一段元素void clear( void );// 删除所有元素}

大小和容量

template < class T, class A = allocator<T> > class std::vector {public:size_type size( void ) const;// 元素个数bool empty( void ) const;size_type max_size() const;// vector的最大可能规模void resize( size_type sz, T val = T() );// 增加的元素用val初始化size_type capacity( void ) const;// 当前已分配存储的大小（可容纳元素个数）void reserve( size_type n );// 做出总数为n个元素的空位，不初始化。如果n > max_size()，则抛出length_error}

其他成员函数

template < class T, class A = allocator<T> > class std::vector {public:void swap( vector& );allocator_type get_allocator( void ) const;}

交换元素的最明显方式就是简单的复制所有元素。然而，vector常常是用一种类似于到元素组的句柄的结构实现的。这样，交换两个vector的工作可以通过交换它们句柄的方式更有效实现，vector::swap()做的就是这件事。函数get_allocator()是程序员可以取得vector的分配器。如果我们希望在对应用中与某个vector相关的数据做分配时，能保证采用与这个vector本身类似的方式，那么就可以通过这个分配器。

协助函数

template <class T, class A>bool std::operator == ( const vector<T, A>& x, const vector<T, A>& y );template <class T, class A>bool std::operator < ( const vector<T, A>& x, const vector<T, A>& y );

用==和<可以比较两个vector，标准库还提供了!= <= > 和 >=，其定义与==和<相对应。

标准容器：

相关操作和消耗

 [ ]表操作前端操作后端操作迭代器vectorconsto(n)+ const+Ranlist constconstconstBidequeconsto(n)constconstRanstack   const queue  constconst priority_queue  o(log(n))o(log(n)) mapo(log(n))o(log(n))+  Bimultimap o(log(n))+  Biset o(log(n))+  Bimultiset o(log(n))+  Bistringconsto(n)+o(n)+const+Ranarrayconst   Ranvalarrayconst   Ranbitsetconst    
在迭代器一列中的Ran表示随机访问迭代器，Bi表示双向迭代器。对双向迭代器的操作是随机访问迭代器操作的一个子集。const项表示这个操作所用的时间不依赖容易中元素的数目，对常量时间的另一种习惯表示方法是o(1)。o(n)表示操作所用的时间与元素个数成比例。后最+表明偶尔会出现显著的额外时间开销。对于大量数据而言，常量时间将表示“廉价”，o(n)表示“昂贵”，而o(log(n))表示“相当廉价”。对于中等大小的n值，o(log(n))已经更接近常量而不是o(n)。