C++中的vector容器对象学习笔记

C++中数组很坑，有没有类似Python中list的数据类型呢？类似的就是vector！ vector 是同一种类型的对象的集合 ，每个对象都有一个对应的整数索引值。和 string 对象一样，标准库将负责管理与存储元素相关的内存。 我们把 vector 称为容器，是因为它可以包含其他对象 。 一个容器中的所有对象都必须是同一种类型的 。

vector对象的定义和初始化

同样的，使用前，导入头文件#include <vector> 可以使用using声明：using std::vector;

vector 是一个类模板（class template）。使用模板可以编写一个类定义或函数定义，而用于多个不同的数据类型。因此，我们可以定义保存 string 对象的 vector，或保存 int 值的 vector，又或是保存自定义的类类型对象（如 Sales_items 对象）的 vector。

声明从类模板产生的某种类型的对象，需要提供附加信息，信息的种类取决于模板。 以 vector 为例，必须说明 vector 保存何种对象的类型，通过将类型放在类型放在类模板名称后面的尖括号中来指定类型：

vector<T> v1;	保存类型为 T 对象。默认构造函数 v1 为空。
vector<T> v2(v1);	v2 是 v1 的一个副本。
vector<T> v3(n, i);	v3 包含 n 个值为 i 的元素。
vector<T> v4(n);	v4 含有值初始化的元素的 n 个副本。

【注意：1、若要创建非空的 vector 对象，必须给出初始化元素的值；2、当把一个 vector 对象复制到另一个 vector 对象时，新复制的 vector 中每一个元素都初始化为原 vectors 中相应元素的副本。但这两个 vector 对象必须保存同一种元素类型；3、可以用元素个数和元素值对 vector 对象进行初始化。构造函数用元素个数来决定 vector 对象保存元素的

个数，元素值指定每个元素的初始值】

vector对象动态增长 ：

vector 对象（以及其他标准库容器对象）的重要属性就在于 可以在运行时高效地添加元素。

【注意：因为

vector 增长的效率高

，在元素值已知的情况下，最好是动态地添加元素。】
值初始化：

如果没有指定元素的初始化式，那么标准库将自行提供一个元素初始值进行，具体值为何，取决于存储在vector 中元素的数据类型。

如果为int型数据，那么标准库将用 0 值创建元素初始化式；

如果 vector 保存的是含有构造函数的类类型（如 string）的元素，标准库将用该类型的默认构造函数创建元素初始化式；

元素类型可能是没有定义任何构造函数的类类型。这种情况下，标准库仍产生一个带初始值的对象，这个对象的每个成员进行了值初始化。

#include <iostream>
#include <string>
#include <vector>

int main()
{
 std::vector<int> a;
 std::vector<int> b(a);
 std::vector<int> c(10, 23);
 std::vector<std::string> svec(10, "null");
 std::vector<std::string> svec2(10, "hi!");
 std::vector<std::string> svec3(10);
 return 0;
}

注意，没有=号！
vector对象操作方法

和string类似！
.v.empty()

Returns true if v is empty; otherwise returns false如果 v 为空，则返回 true，否则返回 false。

.v.size()

Returns number of elements in v返回 v 中元素的个数。

【注意：1、返回相应 vector 类定义的size_type 的值，和string类似。2、使用 size_type 类型时，必须指出该类型是在哪里定义的。vector 类型总是包括总是

包括 vector 的元素类型 vector<int>::size_type

】

v.push_back(t)

Adds element with value t to end of v在 v 的末尾增加一个值为 t 的元素。以下为例子：

#include <iostream>
#include <string>
#include <cctype>
#include <vector>

int main()
{
 // read words from the standard input and store them as elements in a vector
 std::string word;
 std::vector<std::string> text; // empty vector
 while (std::cin >> word) 
 {
 text.push_back(word); // append word to text
 for(std::vector<int>::size_type ix =0; ix != text.size(); ++ix)
  std::cout<<"Now text["<<ix<< "]is: "<<text[ix]<<std::endl;
 }
 return 0;
}

结果为：

Hello
Now text[0]is: Hello
world!
Now text[0]is: Hello
Now text[1]is: world!

注意：
1、不可以直接输出vector对象！ 和list差别太大了。。。

2、下标操作可以改变已有元素：例如上例，可以在最后加上：text[0] = "elements";

3、当然和list一样，肯定不能text[100] = "elements";在Python中这样操作list回报下标越界， C++中编译不会报错，运行自动退出！【 数组操作时这个会坑死你，不会报错，不会退出！理所当然，缓冲区溢出了，黑客们太喜欢了！ 】

4、由于动态增长， 不能先测试长度 ，而是循环中动态测试！否则会出现莫名其妙的BUG！有人会担心效率？别担心！代价很小【内联函数】。

v[n]

Returns element at position n in v返回 v 中位置为 n 的元素。

（1）v1 = v2[/code]

Replaces elements in v1 by a copy of elements in v2把 v1 的元素替换为 v2 中元素的副本。

（2）v1 == v2[/code]

Returns true if v1 and v2 are equal如果 v1 与 v2 相等，则返回 true。

（3）!=, <, <=,>, and >=

Have their normal meanings保持这些操作符惯有的含义。

一个简单的例子

读入一段文本到 vector 对象，每个单词存储为 vector 中的一个元素。把vector 对象中每个单词转化为大写字母。输出 vector 对象中转化后的元素，每八个单词为一行输出。

假设文本为：in the vector. transform each word into uppercase letters. Print the transformed elements from the vector, printing eight words to a line.

#include <iostream>
#include <string>
#include <vector>

std::string deal_word(std::string word)
{
 std::string WORD; // 创建空字符串
 for(std::string::size_type ix =0; ix != word.size(); ++ix)
 {
 if (not ispunct(word[ix]))
 {
  WORD += toupper(word[ix]); //连接非标点字符到字符串
 }
 }
 return WORD;
}

int main()
{
 std::string word; // 缓存输入的单词
 std::vector<std::string> text; // empty vector
 std::cout<<"Please input the text:"<<std::endl; //提示输入
 while (std::cin >> word and word != "INPUTOVER") // INPUTOVER 用于标示输入结束，也可以ctrl + z停止输入 
 {
 word = deal_word(word); // 单词处理
 text.push_back(word); // append word to text
 }
 for(std::vector<int>::size_type ix =0, j = 0; ix != text.size(); ++ix, ++j)
 {
 if (j==8) // 8个单词一行
 {
  std::cout<<std::endl; //换行
  j = 0; //重新计数
 }
  std::cout<<text[ix]<<" "; //加空格！
 }
 return 0;
}

结果为：

Please input the text:
in the vector. transform each word into uppercase letters. Print the transformed elements from the vector, printing eight words to a line. INPUTOVER
IN THE VECTOR TRANSFORM EACH WORD INTO UPPERCASE 
LETTERS PRINT THE TRANSFORMED ELEMENTS FROM THE VECTOR 
PRINTING EIGHT WORDS TO A LINE

vector.resize 与 vector.reserve

reserve是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当加入新的元素时，需要用push_back()/insert()函数。
resize是改变容器的大小，并且创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。
再者，两个函数的形式是有区别的，reserve函数之后一个参数，即需要预留的容器的空间；resize函数可以有两个参数，第一个参数是容器新的大小，第二个参数是要加入容器中的新元素，如果这个参数被省略，那么就调用元素对象的默认构造函数。下面是这两个函数使用例子：

vector<int> myVec;

myVec.reserve( 100 );  // 新元素还没有构造,

       // 此时不能用[]访问元素

for (int i = 0; i < 100; i++ )

...{

  myVec.push_back( i ); //新元素这时才构造

}

myVec.resize( 102 );  // 用元素的默认构造函数构造了两个新的元素

myVec[100] = 1;   //直接操作新元素

myVec[101] = 2;

初次接触这两个接口也许会混淆，其实接口的命名就是对功能的绝佳描述，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 < size()) 
  erase(begin() + new_size, end()); // erase区间范围以外的数据，确保区间以外的数据无效
 else
  insert(end(), new_size - size(), x); // 填补区间范围内空缺的数据，确保区间内的数据有效
｝