顺序容器的元素排列次序与元素值无关，而是由元素添加到容器里的次序决定。
顺序容器包括vector，list，deque，它们的差别在于访问元素的方式，以及添加，或删除元素相关操作的代价。
所以容器都是类模板，所以定义容器必须加<>，举例如下：
Vector<int >sint;
Vector<string>svec;
List<int>ilist;
Deque<int>Dint;
所有容器类型都定义了默认构造函数，用于创建制定类型的空容器对象。默认构造函数不带参数。
(一)vector
1）将一个容器初始化为另一个容器的副本
当不使用默认构造函数，而是用其他构造函数初始化顺序容器时，必须指出该容器有多少个元素，并提供这些元素的初值。
如：
Vector <int> ivec; //采用默认构造函数
Vector <int> ivec2(ivec); //ok
将一个容器复制给另一个容器时，类型必须匹配：容器类型和元素类型都必须相同。举例如下：
List<int> ilist(ivec); //error 容器类型不一致；
Vector<double>dvec(ivec); //error 元素类型不一致
2）初始化为一段元素的副本
使用迭代器间接将一个容器内的元素复制给另一个容器，此时，不要求容器的类型相同，元素类型也可以不同，但是必须能够将要复制的元素转换为所构建的新容器的元素类型；
List<string>slist(svec.begin(),svec.end());
Vector <string>::iteratormid=svec.begin+svec.size()/2;
Deque <string>front(svec.begin(),mid)；
Deque<string>back(mid,svec.end());
3）分配和初始化指定数目的元素
创建顺序容器时，可显式指定容器大小和一个（可选）元素初始化式。
如：
List <string>sList(64,”hello”);这段代码表示sList含有64个元素，每个元素被初始化为hello。
Vector 的应用举例如下：该例来自msdn
#include
"stdafx.h"
//vector_ctor.cpp
//compile with: /EHsc
#include
<vector>
#include
<iostream>
int _tmain(intargc,
_TCHAR*argv[])
{
using
namespace std;
vector<int>::iteratorv1_Iter,v2_Iter,v3_Iter,v4_Iter,v5_Iter;
// Create anempty vector v0
vector<int>v0;
// Create avector v1 with 3 elements of default value 0
vector<int>v1(3 );
// Create avector v2 with 5 elements of value 2
vector<int>v2(5, 2);
// Create avector v3 with 3 elements of value 1 and with the allocator
// of vector v2
vector<int>v3(3, 1,
v2.get_allocator() );
// Create a copy,vector v4, of vector v2
vector<int>v4(v2 );
// Create avector v5 by copying the range v4[_First, _Last)
vector<int>v5(v4.begin() + 1,v4.begin()
+ 3 );
cout<<
"v1 =" ;
for (
v1_Iter = v1.begin( ) ;v1_Iter!=
v1.end() ;v1_Iter++ )
cout<<
" " << *v1_Iter;
cout<<
endl;
cout<<
"v2 =" ;
for (
v2_Iter = v2.begin( ) ;v2_Iter!=
v2.end() ;v2_Iter++ )
cout<<
" " << *v2_Iter;
cout<<
endl;
cout<<
"v3 =" ;
for (
v3_Iter = v3.begin( ) ;v3_Iter!=
v3.end() ;v3_Iter++ )
cout<<
" " << *v3_Iter;
cout<<
endl;
cout<<
"v4 =" ;
for (
v4_Iter = v4.begin( ) ;v4_Iter!=
v4.end() ;v4_Iter++ )
cout<<
" " << *v4_Iter;
cout<<
endl;
cout<<
"v5 =";
for (
v5_Iter = v5.begin( ) ;v5_Iter!=
v5.end() ;v5_Iter++ )
cout<<
" " << *v5_Iter;
cout<<
endl;
return 0;
}
输出结果为：
其中get_allocator 返回内存分配器；
Vector容器中的函数（http://blog.csdn.net/sun_top/article/details/4213398）：
1）构造函数
vector();
vector( size_type num, const TYPE &val );
vector( const vector &from );
vector( input_iterator start, input_iterator end );
C++ Vectors可以使用以下任意一种参数方式构造:
无参数 - 构造一个空的vector,
数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector
vector(from) - 构造一个与vector from 相同的vector
迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).
举例,下面这个实例构造了一个包含5个值为42的元素的Vector
vector<int> v1( 5, 42 );
2）运算符
运算符
语法:
v1 == v2
v1 != v2
v1 <= v2
v1 >= v2
v1 < v2
v1 > v2
v[]
C++ Vectors能够使用标准运算符: ==, !=, <=, >=, <, 和 >. 要访问vector中的某特定位置的元素可以使用 [] 操作符.
两个vectors被认为是相等的，如果：
它们具有相同的容量。
所有相同位置的元素相等。
vectors之间大小的比较是按照词典规则。
1） assign函数
语法:
void assign( input_iterator start, input_iterator end );
void assign( size_type num, const TYPE &val );
assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容。
2） at函数
语法:
TYPE at( size_type loc );
at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素。 例如，考虑下面的代码：
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is "<< v[i] << endl;
}
这段代码访问了vector末尾以后的元素,这将可能导致很危险的结果.以下的代码将更加安全:
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is "<< v.at(i) << endl;
}
取代试图访问内存里非法值的作法,at() 函数能够辨别出访问是否越界并在越界的时候抛出一个异常out_of_range。
5）back函数
语法:
TYPE back();
back() 函数返回当前vector最末一个元素的引用.例如:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
cout << "The first element is " << v.front()
<< " and the last element is "<< v.back() << endl;
这段代码产生如下结果:
The first element is 0 and the last element is 4
6）begin 函数
语法:
iterator begin();
begin()函数返回一个指向当前vector起始元素的迭代器.例如,下面这段使用了一个迭代器来显示出vector中的所有元素:
vector<int> v1( 5, 789 );
vector<int>::iterator it;
for( it = v1.begin(); it != v1.end(); it++ )
cout << *it << endl;
7）capacity函数
语法:
size_type capacity();
capacity() 函数 返回当前vector在重新进行内存分配以前所能容纳的元素数量。
8）clear函数
语法:
void clear();
clear()函数删除当前vector中的所有元素。
9）empty 函数
语法:
bool empty();
如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false.例如,以下代码清空一个vector,并按照逆序显示所有的元素:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
while( !v.empty() ) {
cout << v.back() << endl;
v.pop_back();
}
10）end 函数
语法:
iterator end();
end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,如果你要访问末尾元素,需要先将此迭代器自减1.
11）erase 函数
语法:
iterator erase( iterator loc );
iterator erase( iterator start, iterator end );
erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器.例如:
// 创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
int size = alphaVector.size();
vector<char>::iteratorstartIterator;
vector<char>::iterator tempIterator;
for(int i=0; i < size; i++ )
{
tartIterator = alphaVector.begin();
alphaVector.erase( startIterator );
// Display the vector
for( tempIterator = alphaVector.begin(); tempIterator !=alphaVector.end(); tempIterator++ )
cout << *tempIterator;
cout << endl;
}
这段代码将会显示如下输出:
BCDEFGHIJ
CDEFGHIJ
DEFGHIJ
EFGHIJ
FGHIJ
GHIJ
HIJ
IJ
J
Erase和pop_pack的区别：
Pop_pack只能删除一个最后一个元素，而Erase可以删除一个或多个元素。
12）front 函数
语法:
TYPE front();
front()函数返回当前vector起始元素的引用
get_allocator 函数
语法:
allocator_type get_allocator();
get_allocator() 函数返回当前vector的内存分配器.在STL里面一般不会调用new或者alloc来分配内存,而且通过一个allocator对象的相关方法来分配.
示例:vector<int>v3( 3, 1,v2.get_allocator( ));//把V2的内存分配器作为一个参数参与构造V3。这样，它们两个用一个内存分配器了。
13）insert 函数
语法：
iterator insert( iterator loc, const TYPE &val );
void insert( iterator loc, size_type num, const TYPE &val );
void insert( iterator loc, input_iterator start, input_iterator end );
insert() 函数有以下三种用法：
在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,
在指定位置loc前插入num个值为val的元素
在指定位置loc前插入区间[start, end)的所有元素。
举例：
//创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
//插入四个C到vector中
vector<char>::iterator theIterator = alphaVector.begin();
alphaVector.insert( theIterator, 4, 'C' );
//显示vector的内容
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end();theIterator++ )
cout << *theIterator;
这段代码将显示:
CCCCABCDEFGHIJ
14）max_size 函数
语法:
size_type max_size();
max_size() 函数返回当前vector所能容纳元素数量的最大值(译注:包括可重新分配内存).
15）push_back 函数
语法:
void push_back( const TYPE &val );
push_back()添加值为val的元素到当前vector末尾
rbegin 函数
语法:
reverse_iterator rbegin();
rbegin函数返回指向当前vector末尾的逆迭代器.(译注:实际指向末尾的下一位置,而其内容为末尾元素的值,详见逆代器相关内容)
示例:
vector<int>v1;
for(int i=1;i<=5;i++)
{
v1.push_back(i);
}
vector<int>::reverse_iterator pos;
pos=v1.rbegin();
cout<<*pos<<" ";
pos++;
cout<<*pos<<endl;
输出结果为:5 4。
16）rend 函数
语法:
reverse_iterator rend();
rend()函数返回指向当前vector起始位置的逆迭代器.
示例:
vector<int>v1;
for(int i=1;i<=5;i++)
{
v1.push_back(i);
}
vector<int>::reverse_iterator pos;
pos=v1.rend();
pos--;
cout<<*pos<<" ";
pos--;
cout<<*pos<<endl;
输出结果为:1 2
17）reserve 函数
语法:
void reserve( size_type size );
reserve()函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)
18）resize 函数
语法:
void resize( size_type size, TYPE val );
resize() 函数改变当前vector的大小为size,且对新创建的元素赋值val
resize与reserve的区别
reserve是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当加入新的元素时，需要用push_back()/insert()函数。
resize是改变容器的大小，并且创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。再者，两个函数的形式是有区别的，reserve函数之后一个参数，即需要预留的容器的空间；resize函数可以有两个参数，第一个参数是容器新的大小，第二个参数是要加入容器中的新元素，如果这个参数被省略，那么就调用元素对象的默认构造函数。
初次接触这两个接口也许会混淆，其实接口的命名就是对功能的绝佳描述，resize就是重新分配大小，reserve就是预留一定的空间。这两个接口即存在差别，也有共同点。下面就它们的细节进行分析。
为实现resize的语义，resize接口做了两个保证：
一是保证区间[0, new_size)范围内数据有效，如果下标index在此区间内，vector[indext]是合法的。
二是保证区间[0, new_size)范围以外数据无效，如果下标index在区间外，vector[indext]是非法的。
reserve只是保证vector的空间大小(capacity)最少达到它的参数所指定的大小n。在区间[0, n)范围内，如果下标是index，vector[index]这种访问有可能是合法的，也有可能是非法的，视具体情况而定。
resize和reserve接口的共同点是它们都保证了vector的空间大小(capacity)最少达到它的参数所指定的大小。
因两接口的源代码相当精简，以至于可以在这里贴上它们：
void resize(size_type new_size) { resize(new_size, T()); }
void resize(size_type new_size, const T& x) {
if (new_size < oldsize)
erase(oldbegin + new_size, oldend); // erase区间范围以外的数据，确保区间以外的数据无效
else
insert(oldend, new_size - oldsize, x); // 填补区间范围内空缺的数据，确保区间内的数据有效
示例:
#include<iostream>
#include<vector>
using namespace std;
void main()
{
vector<int>v1;
for(int i=1;i<=3;i++)
{
v1.push_back(i);
}
v1.resize(5,8);//多出的两个空间都初始化为8，
for(i=0;i<v1.size();i++)//resize与reserver并不会删除原先的元素以释放空间
{
cout<<v1[i]<<" ";
}
cout<<endl;
v1.reserve(7);// 新元素还没有构造,
for(i=0;i<7;i++)
{
cout<<v1[i]<<" ";//当i>4,此时不能用[]访问元素
}
cout<<endl;
cout<<v1.size()<<endl;
cout<<v1.capacity()<<endl;
}
输出结果为:
1 2 3 8 8
1 2 3 8 8 -842150451 -842150451
5
7
19）size 函数
语法:
size_type size();
size() 函数返回当前vector所容纳元素的数目
20）swap 函数
语法:
void swap( vector &from );
swap()函数交换当前vector与vector from的元素
示例:
vector<int>v1,v2;
for(int i=1;i<=3;i++)
{
v1.push_back(i);
v2.push_back(i);
}
v2.push_back(4);
v2.push_back(5);
v1.swap(v2);
for(int j=0;j<v1.size();j++)
{
cout<<v1[j]<<" ";
}
cout<<endl;
for(int k=0;k<v2.size();k++)
{
cout<<v2[k]<<" ";
}
cout<<endl;
输出结果为:
1 2 3 4 5
1 2 3