标准库功能：
- 提供了对一些语言特征的支持，例如，对于存储管理和运行时类型信息的支持。
- 提供了有关实现所确定的语言方面的一些信息，例如最大的float值。
- 提供了那些无法在每个系统上由语言本身做出最优实现的函数，如sqrt()和memmove()
- 提供了一些非基本的功能，使程序员可以为可移植性而依靠它们，例如表，映射，排序函数和I/O流。
- 提供了一个为扩展它所提供功能的基本框架。例如，使用户可以按照内部类型I/O的风格为用户定义类型提供I/O机制的规制和支持功能。
- 为其他库提供一个公共的基础。
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的副本 }
堆栈操作
push_bak()将隐式地导致vector的size()的增长，所有vector不会上溢（只要还存在可以申请到的内存）。然而，vector确实可能下溢，下溢的效果是无定义的。pop_back()的最明显实现方式可能导致不属于vector的内存被复写。template < class T, class A = allocator<T> > class std::vector { public: void push_back( const T& x ); // 在最后加入 void pop_back(); // 删除最后元素 }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前加入x void 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，标准库还提供了!= <= > 和 >=，其定义与==和<相对应。
标准容器：
相关操作和消耗
[ ] 表操作 前端操作 后端操作 迭代器 vector const o(n)+ const+ Ran list const const const Bi deque const o(n) const const Ran stack const queue const const priority_queue o(log(n)) o(log(n)) map o(log(n)) o(log(n))+ Bi multimap o(log(n))+ Bi set o(log(n))+ Bi multiset o(log(n))+ Bi string const o(n)+ o(n)+ const+ Ran array const Ran valarray const Ran bitset const
在迭代器一列中的Ran表示随机访问迭代器，Bi表示双向迭代器。对双向迭代器的操作是随机访问迭代器操作的一个子集。const项表示这个操作所用的时间不依赖容易中元素的数目，对常量时间的另一种习惯表示方法是o(1)。o(n)表示操作所用的时间与元素个数成比例。后最+表明偶尔会出现显著的额外时间开销。对于大量数据而言，常量时间将表示“廉价”，o(n)表示“昂贵”，而o(log(n))表示“相当廉价”。对于中等大小的n值，o(log(n))已经更接近常量而不是o(n)。
206
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
