探索C/C++的奥秘之vector

vector<int>是一个类模板，要显示的实例化，并且vector<char>不能代替string。原因：

1.string和vector<char>再结构上有所不同，string要保证末尾有\0，sting就是自动生成的\0，vector<char>要手动插入\0。

2.string的接口比vector多，string有+=，vector也可以比较大小，但是vector的比较大小是没有意义的。

vector中可以存放string，vector<string>，vector里面还可以存vector<vector<int>>，这个里面就是二维数组了。

1.vector的介绍及使用

1.1 vector的介绍

1. vector是表示可变大小数组的序列容器。

2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。

4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。

5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。

6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list 统一的迭代器和引用更好。

vector的原型：

声明的时候有两个模板参数，一个模板参数是T，这个T是把它里面存储的数据类型进行实例化，第二个模板参数是空间配置器Alloc，也就是一个内存池，STL的所有容器都用的是这个内存池，能提高效率，它给了一个缺省参数，缺省的参数就是自己给内存池，

1.2 vector的使用

1.2.1 vector的定义

vector的构造函数，第一个是无参构造，是全缺省的，第二个是n个val的构造，value_type是typedef出来的，其实就是T，还可以用一段迭代器区间初始化，还可以拷贝构造。

接下来我们来演示一下：

int main()
{
   vector<int> v1(10, 1);
   vector<string> v2(10, "xxx");
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   for (auto e : v2)
   {
       cout << e << " ";
   }
   cout << endl;
   //自己的迭代器
   vector<int> v3(v1.begin(), v1.end());
   for (auto e : v3)
   {
       cout << e << " ";
   }
   cout << endl;
   //野生驯化的迭代器
   string s1("hello world");
   vector<char> v4(s1.begin(), s1.end());
   for (auto e : v4)
   {
       cout << e << " ";
   }
   cout << endl;
   //野生的迭代器
   //也可以这样初始化
   int a[] = { 16,2,77,29 };
   vector<int> v5(a, a + 4);//数组名代表首元素的地址
   for (auto e : v5)
   {
       cout << e << " ";
   }
   cout << endl;
   return 0;
}

STL最核心的部分是它是一套数据结构算法的框架，STL叫容器和算法，容器时存数据的，算法是对数据进行处理的。什么是算法呢？比如说查找，二分查找、正常查找，还有排序等。算法是通过迭代器访问容器中的数据的。在算法的头文件里面，C++提供了两个sort。这两个sort算法底层用的是快排算法，用迭代器去访问。

这也是模板，意味着不仅仅可以作用在一个容器上去，各种容器只要符合它的要求，它都可以作用上去。跟我们的迭代器区间用法一样，传一个迭代器区间就可以，并且要包一个算法的头文件。

int main()
{
   int a[] = { 16,2,77,29 };
   vector<int> v1(a, a + 4);
   sort(v1.begin(), v1.end());
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   return 0;
}

默认的是升序，升序用的是“<”(less)，如果要排降序，需要用到上图中的模板参数Compare comp，降序要用到“>”，但是>不是说要用这个符号，而是要传一个类对象过去，库里面有一个greater<>，greater也是一个模板，我要要传一个，我们定义一个greater的对象传过去，就可以排了。

//迭代器区间都是左闭右开，最后一个位置不参与
int main()
{
   int a[] = { 16,2,77,29 };
   vector<int> v1(a, a + 4);
   sort(v1.begin(), v1.end());
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   greater<int> g;
   //sort(v1.begin(), v1.end(), g);//这里的g也可以用匿名对象greater<int>()
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   //string也可以排序
   string s1("hello world");
   sort(s1.begin(), s1.end());
   vector<char> v2(s1.begin(), s1.end());
   for (auto e : v2)
   {
       cout << e;
   }
   cout << endl;
   //数组也可以排序
   sort(a, a + 4);
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   return 0;
}

1.2.2 vector iterator 的使用

int main()
{
   int a[] = { 16,2,77,29 };
   vector<int> v1(a, a + 4);
   sort(v1.begin(), v1.end());
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   //降序也可以用反向迭代器
   sort(v1.rbegin(), v1.rend());
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   return 0;
}

接下来也有意义的两个接口：reserve和resize。

一个常见的错误：

size为0，capacity为10，空间开出来了，但是不能用[]去访问这个空间，[]是怎么实现的，会检查有效位置，有效位置是size，所在的那些位置，一上来就会检查i是不是<这里的size，这里的size为0，程序会崩溃，这里应该用resize。resize把空间开好了，把size也给长上去了，这时候用[]来修改值才可以。

int main()
{
   vector<int> v1;
   v1.resize(10);
   for (size_t i = 0; i < 10; i++)
   {
       v1[i] = i;
   }
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   //如果非要使用reserve要调用push_back
   vector<int> v2;
   v2.reserve(10);
   for (size_t i = 0; i < 10; i++)
   {
       v2.push_back(i);
   }
   for (auto e : v2)
   {
       cout << e << " ";
   }
   cout << endl;
   return 0;
}

断言是在debug版本下生效，release版本下不生效。

1.2.3 vector 增删查改

接下来演示一下头插、头删：

int main()
{
   int a[] = { 16,2,77,29 };
   vector<int> v1(a, a + 4);
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   //头删
   v1.erase(v1.begin());
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   //头插
   v1.insert(v1.begin(), 100);
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   //删除第3个位置的数据
   v1.erase(v1.begin() + 2);
   for (auto e : v1)
   {
       cout << e << " ";
   }
   cout << endl;
   return 0;
}

如果我们想删除3，但是又不知道哪个位置该怎么办？

vector中没有find的接口，string中有find的接口，算法(algorithm)中有find的接口。这个find写的是一个函数模板，找到返回的是迭代器，找不到返回的就是last，last不是最后一个数据，是最后一个数据的下一个位置。

string中的find很多样化，首先查找字符不一定从0开始找，可能从某个起点位置开始找，它的接口是特殊化的，有时候还可能找一个字串，所有string单独实现find，string的功能需求比较特殊，vector也可以自己实现，但是没有必要，因为vector要跟其它容器复用，vector、list，包括后面要学习的链表等都是需要find。list的接口也没有find。这个时候写成一个模板，又有一个迭代器区间，传迭代器区间给我，传vector就是vector的查找，list就是list的查找，不需要我们自己去写了。

int main()
{
   //如果我们想删除3，但是又不知道哪个位置该怎么办？
   int arr[] = { 16,2,77,29 ,3,33,43,2 };
   vector<int> v2(arr, arr + sizeof(arr) / sizeof(arr[0]));
   vector<int>::iterator pos = find(v2.begin(), v2.end(), 3);
   if (pos != v2.end())
   {
       v2.erase(pos);
   }
   for (auto e : v2)
   {
       cout << e << " ";
   }
   return 0;
}

int main()
{
   //如果我们想删除3并且有多个3，该怎么办？
   int arr[] = { 16,2,77,29 ,3,33,43,3,2,3,3,2 };
   vector<int> v1(arr, arr + sizeof(arr) / sizeof(arr[0]));
   vector<int>::iterator pos = find(v1.begin(), v1.end(), 3);
   while(pos != v1.end())
   {
       v1.erase(pos);
       pos = find(pos + 1, v1.end(), 3);
   }
   for (auto e : v1)
   {
       cout << e << " ";
   }
   return 0;
}

这段代码程序会奔溃，涉及到一个迭代器失效的问题，迭代器这里暂时不做细讲，后面讲到底层实现以后再讲。可以这样认为，v1.erase(pos)这个位置删除了以后，这个位置的pos迭代器就失效了，这个时候pos = find(pos + 1, v1.end(), 3)就会坑，这个问题先放在这。其实可以从头找，不过效率会变很低。

int main()
{
   //如果我们想删除3并且有多个3，该怎么办？
   int arr[] = { 16,2,77,29 ,3,33,43,3,2,3,3,2 };
   vector<int> v1(arr, arr + sizeof(arr) / sizeof(arr[0]));
   vector<int>::iterator pos = find(v1.begin(), v1.end(), 3);
   while(pos != v1.end())
   {
       v1.erase(pos);
       pos = find(v1.begin(), v1.end(), 3);
   }
   for (auto e : v1)
   {
       cout << e << " ";
   }
   return 0;
}

assign，本来vector有一堆值，assign算是一种赋值，但是它的赋值不是用对象去赋值，而是用一段迭代器区别或者是n个value去赋值，相当于把之前的值清掉了，再把这些值插入进去。

代码演示：

int main()
{
   int arr[] = { 16,2,77,29 ,3,33,43,3,2,3,3,2 };
   vector<int> v1(arr, arr + sizeof(arr) / sizeof(arr[0]));
   v1.assign(10, 1);
   for (auto e : v1)
   {
       cout << e << " ";
   }
   return 0;
}

vs下vector的扩容逻辑：

void TextVectorExpand()
{
   size_t sz;
   vector<int> v;
   sz = v.capacity();
   cout << "making v grow:\n";
   for (size_t i = 0; i < 100; i++)
   {
       v.push_back(1);
       if (sz != v.capacity())
       {
           sz = v.capacity();
           cout << "capacity changed : " << sz << '\n';
       }
   }
}

int main()
{
   TextVectorExpand();
   return 0;
}