vector的主要操作

vector常用方法

---

assign() 对Vector中的元素赋值

void assign( input_iterator start, input_iterator end ); //
void assign( size_type num, const TYPE &val );

reserve() 设置Vector最小的元素容纳数量 函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)

resize() 改变Vector元素数量的大小 函数改变当前vector的大小为size,且对新创建的元素赋值val

swap() 交换两个Vector

capacity() 返回vector所能容纳的元素数量(在不重新分配内存的情况下）

max_size() 返回Vector所能容纳元素数量的最大值(译注:包括可重新分配内存).

size() 返回Vector元素数量的大小

get_allocator() 返回vector的内存分配器

http://blog.csdn.net/qingqinglanghua/article/details/5035763

vector.reserve(size)和vector.resize(size,t*)的区别

---

reserve是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当加入新的元素时，需要用push_back()/insert()函数。

resize是改变容器的大小，并且创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。

再者，两个函数的形式是有区别的，reserve函数之后一个参数，即需要预留的容器的空间；resize函数可以有两个参数，第一个参数是容器新的大小，第二个参数是要加入容器中的新元素，如果这个参数被省略，那么就调用元素对象的默认构造函数。下面是这两个函数使用例子：

vector<int> myVec;
myVec.reserve(  );     // 新元素还没有构造,
                          // 此时不能用[]访问元素
for (int i = ; i < ; i++ )
{
     myVec.push_back( i ); //新元素这时才构造
}
myVec.resize(  );      // 用元素的默认构造函数构造了两个新的元素
myVec[] = ;           //直接操作新元素
myVec[] = ;

初始化及清零

---

二维vector的初始化：

定义空二维vector，再赋值

vector<vector <int> > ivec(m ,vector<int>(n)); //m*n的二维vector，注意两个 "> "之间要有空格！
void assign(const_iterator first, const_iterator last);

void assign( size_type _Count, const Type& _Val ); // 赋值，用指定元素序列替换容器内所有元素

vector<vector <int> > ivec(m ,vector<int>(n,0)); //m*n的二维vector，所有元素初始化为0

1.将一个容器初始化为另一个容器的副本

2.初始化为一段元素的副本

3.分配和初始化指定数目的元素

vector<string> v1;         // 创建空容器，其对象类型为string类
vector<int> ivec;
vector<int> ivec2(ivec);                                                    //1

vector<string> v4(v3.begin(), v3.end());  // v4是与v3相同的容器（完全复制）     //2
vector<string> v2();     // 创建有10个具有初始值（即空串）的string类对象的容器   //3
vector<string> v3(, "hello"); // 创建有5个值为“hello”的string类对象的容器      //3

其中2还可以通过使用内置数组中的一对指针初始化容器，示例如下：

char *words[] = {"stately", "plump", "buck", "mulligan"};
// calculate how many elements in words
size_t words_size = sizeof(words)/sizeof(char*);
// use entire array to initialize words2
vector<string> words2(words, words+words_size);  //其中第二个指针words+words_size提供停止复制的条件，其所指向的位置上存放的元素并没有复制

使用STL vector的几种清空容器（删除）办法

iterator erase(iterator it); // 删除指定元素，并返回删除元素后一个元素的位置（如果无元素，返回end()）
iterator erase(iterator first, iterator last); // 注意：删除元素后，删除点之后的元素对应的迭代器不再有效。

void clear() const; // 函数删除当前vector中的所有元素，相当于调用erase( begin(), end())

http://hi.baidu.com/ljjyxz123/blog/item/c3bab7f50aabbc05bd31096e.html

assign和resize

---

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

assign() 函数要么将区间[first, last)的元素赋到当前vector,或者赋n个值为u的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.
注意：assign操作首先删除vector容器内的所有元素，然后将参数指定的新元素插入到该容器中。

参数
first, last
标记一段范围的一对迭代器，即将[first,last)标记范围内所有元素复制到当前的vector中.包含first所指向的元素，不包含last所指向的元素。

n,u
表示将当前vector中重新设置为存储n个值为t的元素

void resize ( size_type sz, T c = T() );

改变长度
把当前 vector容器的的长度大小重设为sz
如果sz小于当前vector容器的size，则删除多出来的元素，否则采用值为 T 来初始化新添加的元素

参数

sz
要设置当前vector的size的值
Member type size_type is an unsigned integral type.

c
用初始化的新添加的元素的值。
可为空，为空则表示采用值初始化来初始化新添加的元素

resize函数有2个重载版本，一个只有一个size_type参数，一个除了size_type参数外还有_Ty _val，即“可选”新元素值。

先说第一个版本：

void resize(size_type _Newsize)
{ // determine new length, padding with _Ty() elements as needed
resize(_Newsize, _Ty());
}

可见它用_Ty()做第2个参数，调用了它的第2个版本。第2个版本的定义如下：

void resize(size_type _Newsize, _Ty _Val)
{ // determine new length, padding with _Val elements as needed
if (size() < _Newsize)
_Insert_n(end(), _Newsize - size(), _Val);
else if (_Newsize < size())
erase(begin() + _Newsize, end());
}

由定义可知，对于第一个版本：

若_Newsize小于oldsize，则剩余元素值不变。

若_Newsize大于oldsize，则新添加的元素值用元素的默认构造参数初始化（特别的，int型的将被初始化为0）。

对于第2个版本：

若_Newsize小于oldsize，则剩余元素值不变。（全部调用erase(begin() + _Newsize, end())擦除掉多余元素）

若_Newsize大于oldsize，则新添加的元素值用提供的第2个参数初始化。

不管用哪个版本，[0,min(_Newsize,oldsize))范围内的值均保持不变。

capcity和size

---

CAPCITY是此容器当前可以容纳的最大元素个数，就是不用重新分配内存是可以容纳的个数 
SIZE是现在容器中已经存在的元素个数
所以容量＞＝长度

vector <int> a(10); 
a.push_back(1); 
此时a.size()=1,a.capacity()=10

reverse和resize

---

vector 的reverse只是增加了vector的capacity，但是size没有改变！
resize同时改变了vector的capacity和size！

reserve是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当加入新的元素时，需要用push_back()/insert()函数。

resize是改变容器的大小，并且创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。

再者，两个函数的形式是有区别的，reserve函数之后一个参数，即需要预留的容器的空间；resize函数可以有两个参数，第一个参数是容器新的大小，第二个参数是要加入容器中的新元素，如果这个参数被省略，那么就调用元素对象的默认构造函数。

vector<int> myVec;
myVec.reserve(  );     // 新元素还没有构造,
                          // 此时不能用[]访问元素
for (int i = ; i < ; i++ )
{
     myVec.push_back( i ); //新元素这时才构造
}
myVec.resize(  );      // 用元素的默认构造函数构造了两个新的元素
myVec[] = ;           //直接操作新元素
myVec[] = ;  

为实现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)最少达到它的参数所指定的大小。

http://blog.sina.com.cn/s/blog_749f55cd0100p5qw.html

http://bbs.bccn.net/thread-91130-1-1.html

vector list 赋值速度比较

---

v2 = v1;//用赋值操作符赋值vector()(3rd)

l2 = l1;//用赋值操作符赋值list

v2.assign(v1.begin(), v1.end());//用assign给vector赋值(1st)

l2.assign(l1.begin(), l1.end());//用assign给list赋值

copy(v1.begin(), v1.end(), inserter(v2, v2.begin()));//用copy算法给vector赋值(插入迭代器方式)(5nd)

copy(l1.begin(), l1.end(), inserter(l2, l2.begin()));//用copy算法给list赋值（插入迭代器方式）

v2.resize(v1.size());

copy(v1.begin(), v1.end(), v2.begin());//用copy算法给vector赋值（resize）(2nd)

l2.resize(l1.size());

copy(l1.begin(), l1.end(), l2.begin());//用copy算法给list赋值（resize）

v2.assign(l1.begin(), l1.end());//用assign给vector赋值(从list)(4st)

l2.assign(v1.begin(), v1.end());//用assign给list赋值(从vector)

总结：
vector:对于vector赋值方式中，assign的速度是最快的，其次是resize以后用copy算法赋值，而最先能够想到的赋值操作符，速度却并不快，只能够排名第三，目前还不知道这是为什么，采用插入迭代器再用copy的方式是速度最慢的一种。
list:对于list赋值，赋值操作符的速度是最快的，其次是assign，然后是采用resize的copy，最后一位同样是采用插入迭代子方式的copy。

主要引自：http://www.cnblogs.com/wei-li/archive/2012/06/08/2541576.html