文章目录

• 1.vector的介绍及使用
• • 1.1 vector基本概念
  • 1.2 vector的使用
  • • 1.2.1 vector的定义 (构造函数)
    • 1.2.2 vector的迭代器使用
    • 1.2.3 vector 增删查改
    • 1.2.4 vector 迭代器失效问题（重点）
    • 1.2.5 vector 空间增长问题
• 2. vector的模拟实现
• • 2.1 SGI版vector实现示意图
  • 2.2 具体实现代码

1.vector的介绍及使用

vector的文档介绍（包含函数接口使用）

1.1 vector基本概念

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

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

功能：

• vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：

• 不同之处在于数组是静态空间，而vector可以动态扩展

1.2 vector的使用

vector学习时一定要学会查看文档：>vector的文档介绍<
vector在实际中非常的重要，在实际中我们熟悉常
见的接口就可以，下面列出了哪些接口是要重点掌握的。

1.2.1 vector的定义 (构造函数)

#include void printVector(vector& v) {for (vector::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl;
}
int main() {vector v1; //无参构造for (int i = 0; i < 10; i++){v1.push_back(i);}printVector(v1);vector v2(v1.begin(), v1.end());//使用迭代器进行初始化构造printVector(v2);vector v3(10, 100); //构造并初始化10个100printVector(v3);vector v4(v3);//拷贝构造printVector(v4);return 0;
}

小提醒：vector的多种构造方式比较多，灵活运用即可

1.2.2 vector的迭代器使用

在上面的构造函数中，我们可以看到其中有一个接口是用迭代器构造的，这里有一个新的概念，什么是迭代器？

简单来讲，迭代器和 C++ 的 指针 非常类似，它可以是需要的任意类型，通过迭代器可以指向容器中的某个元素，如果需要，还可以对该元素进行读/写操作。

注意：迭代器的行为像指针，也就是说可以像用指针一样使用迭代器，但它不一定是指针（比如list的迭代器），具体是什么，后续学习其他容器模拟实现即可理解！！！

#include 
#include 
using namespace std;
int main()
{vector v(10, 1);//构造10个1std::vector::iterator it = v.begin();//获取v的开始的迭代器，类型是std::vector::iterator//auto it1 = v.begin();//类型太长，可以使用autostd::vector::iterator end = v.end();//获取v的结尾的迭代器while (it != end){cout << *it << " "; //*解引用之后，就可以拿到数据，跟指针*p的操作一样++it;//让迭代器往后移一位，跟指针的++p类似}cout << endl;return 0;
}

小提醒：迭代器在STL中非常好用，它屏蔽了底层的细节，保证了用户使用的一致性，而且在后续学习更多容器的时候，迭代器的用法几乎一样

1.2.3 vector 增删查改

插入和删除示例：

#include 
void printVector(vector& v) {for (vector::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";}cout << endl;
}int main() {//插入和删除vector v1;//尾插v1.push_back(10);v1.push_back(20);v1.push_back(30);v1.push_back(40);v1.push_back(50);printVector(v1);//尾删v1.pop_back();printVector(v1);//插入v1.insert(v1.begin(), 100);printVector(v1);v1.insert(v1.begin(), 2, 1000);printVector(v1);//删除v1.erase(v1.begin());printVector(v1);//清空v1.erase(v1.begin(), v1.end());v1.clear();printVector(v1);return 0;
}

总结：

• 尾插 — push_back
• 尾删 — pop_back
• 插入 — insert (位置迭代器)
• 删除 — erase （位置迭代器）
• 清空 — clear

数据存取示例：

#include 
int main()
{vectorv1;for (int i = 0; i < 10; i++){v1.push_back(i);}for (int i = 0; i < v1.size(); i++){cout << v1[i] << " ";}cout << endl;for (int i = 0; i < v1.size(); i++){cout << v1.at(i) << " ";}cout << endl;cout << "v1的第一个元素为： " << v1.front() << endl;cout << "v1的最后一个元素为： " << v1.back() << endl;return 0;
}

总结：

• 除了用迭代器获取vector容器中元素，[ ]和at也可以
• front返回容器第一个元素
• back返回容器最后一个元素

赋值重载示例：

#include void printVector(vector& v) {for (vector::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";}cout << endl;
}int main()
{vector v1; //无参构造for (int i = 0; i < 10; i++){v1.push_back(i);}printVector(v1);vectorv2;v2 = v1;//赋值重载printVector(v2);vectorv3;v3.assign(v1.begin(), v1.end());printVector(v3);vectorv4;v4.assign(10, 100);printVector(v4);return 0;
}

总结： vector赋值方式比较简单，使用operator=或者assign都可以

1.2.4 vector 迭代器失效问题（重点）

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了
封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器底层对应指针所指向的
空间被销毁了，而使用一块已经被释放的空间，造成的后果是程序崩溃(即如果继续使用已经失效的迭代器，
程序可能会崩溃)。

对于vector可能会导致其迭代器失效的操作有：

1. 会引起其底层空间改变的操作，都有可能是迭代器失效，比如：resize、reserve、insert、assign、
   push_back等。

2. 指定位置元素的删除操作--erase

迭代器失效解决办法：在使用前，对迭代器重新赋值即可

示例1

下面的程序运行会崩溃，原因就是因为底层空间发生改变导致迭代器失效

#include 
using namespace std;
#include 
int main()
{vector v{ 1, 2, 3, 4, 5, 6 };auto it = v.begin();// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容// v.resize(100, 8);// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变// v.reserve(100);// 插入元素期间，可能会引起扩容，而导致原空间被释放// v.insert(v.begin(), 0);// v.push_back(8);// 给vector重新赋值，可能会引起底层容量改变v.assign(100, 8);/*出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块已经被释放的空间，而引起代码运行时崩溃。解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可。*/while (it != v.end()){cout << *it << " ";++it;}cout << endl;return 0;
}

示例2

#include 
using namespace std;
#include 
int main()
{int a[] = { 1, 2, 3, 4 };vector v(a, a + sizeof(a) / sizeof(int));// 使用find查找3所在位置的iteratorvector::iterator pos = find(v.begin(), v.end(), 3);// 删除pos位置的数据，导致pos迭代器失效。v.erase(pos);cout << *pos << endl; // 此处会导致非法访问return 0;
}

erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代
器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是
没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

erase删除任意位置代码后，linux下迭代器并没有失效
因为空间还是原来的空间，后序元素往前搬移了，it的位置还是有效的 ,但是如果是删除最后一个元素Linux下也同样会失效

迭代器失效解决办法：在使用前，对迭代器重新赋值即可

1.2.5 vector 空间增长问题

• capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。
  这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义
  的。vs是PJ版本STL，g++是SGI版本STL。

• reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问
  题。

• resize在开空间的同时还会进行初始化，影响size

// 测试vector的默认扩容机制
void TestVectorExpand()
{size_t sz;vector v;sz = v.capacity();cout << "making v grow:\n";for (int i = 0; i < 100; ++i){v.push_back(i);if (sz != v.capacity()){sz = v.capacity();cout << "capacity changed: " << sz << '\n';}}
}
vs：运行结果：vs下使用的STL基本是按照1.5倍方式扩容
making foo grow :
capacity changed : 1
capacity changed : 2
capacity changed : 3
capacity changed : 4
capacity changed : 6
capacity changed : 9
capacity changed : 13
capacity changed : 19
capacity changed : 28
capacity changed : 42
capacity changed : 63
capacity changed : 94
capacity changed : 141g++运行结果：linux下使用的STL基本是按照2倍方式扩容
making foo grow :
capacity changed : 1
capacity changed : 2
capacity changed : 4
capacity changed : 8
capacity changed : 16
capacity changed : 32
capacity changed : 64
capacity changed : 128

// 如果已经确定vector中要存储元素大概个数，可以提前将空间设置足够
// 就可以避免边插入边扩容导致效率低下的问题了
void TestVectorExpandOP()
{vector v;size_t sz = v.capacity();v.reserve(100); // 提前将容量设置好，可以避免一遍插入一遍扩容cout << "making bar grow:\n";for (int i = 0; i < 100; ++i){v.push_back(i);if (sz != v.capacity()){sz = v.capacity();cout << "capacity changed: " << sz << '\n';}}
}

总结：

• 判断是否为空 — empty

• 返回元素个数 — size

• 返回容器容量 — capacity

• 重新指定大小 — resize（减少vector在动态扩展容量时的扩展次数）

动态扩展：

• 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

2. vector的模拟实现

2.1 SGI版vector实现示意图

vector的实现版本也有不少，我们这次实现的对象是相对来说比较简单的SGI 版的vector

SGI版实现vector的示意图

2.2 具体实现代码

#pragma once 
#include 
#include 
using namespace std;//为了和标准库里的vector不冲突，建议用命名空间封装起来
namespace hdm
{template class vector{public:// vector的迭代器是一个原生指针typedef T* iterator;typedef const T* const_iterator;iterator begin(){return _start;}iterator end(){return _finish;}const_iterator begin() const{return _start;}const_iterator end() const{return _finish;}//无参构造vector(): _start(nullptr), _finish(nullptr), _end_of_storage(nullptr){}vector(size_t n,const T& val=T()):_start(nullptr), _finish(nullptr), _end_of_storage(nullptr){reserve(n);while (n--){push_back(val);}}/** 理论上将，提供了vector(size_t n, const T& value = T())之后* vector(int n, const T& value = T())就不需要提供了，但是对于：* vector v(10, 5);* 编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型* 就不会走vector(size_t n, const T& value = T())这个构造方法，* 最终选择的是：vector(InputIterator first, InputIterator last)* 因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int* 但是10和5根本不是一个区间，编译时就报错了* 故需要增加该构造方法*/vector(int n, const T& val = T()):_start(nullptr), _finish(nullptr), _end_of_storage(nullptr){reserve(n);while (n--){push_back(val);}}// 若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器// 重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器template vector(InputIterator first, InputIterator last){while (first != last){push_back(*first);++first;}}//拷贝构造//传统写法//vector(const vector& v)//	:_start(nullptr)//	, _finish(nullptr)//	, _end_of_storage(nullptr)//{//	reserve(v.capacity());//	auto it = v.begin();//	auto it1 = begin();//	while (it != v.end())//	{//		*it1++ = *it++;//	}//	_finish = it1;//}//拷贝构造//现代写法vector(const vector& v):_start(nullptr), _finish(nullptr), _end_of_storage(nullptr){vector tmp(v.begin(), v.end());swap(tmp);}//赋值重载//现代写法vector& operator=(vector tmp){swap(tmp);return *this;}/// vector的修改操作void push_back(const T& val){if (_finish == _end_of_storage){//空间满了就2倍扩容，size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;reserve(newcapacity);}*_finish = val;++_finish;}void pop_back(){erase(end() - 1);}iterator insert(iterator pos,const T& x){assert(pos >= _start &&pos <= _finish);if (_finish == _end_of_storage){size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;reserve(newcapacity);}auto cur = end();while (cur>pos){*cur = *(cur - 1);--cur;}*pos = x;++_finish;return pos;}iterator erase(iterator pos){assert(pos >= _start && pos < _finish && pos!=nullptr);auto cur = pos;while (cur < _finish - 1){*cur = *(cur + 1);++cur;}--_finish;return pos;}void swap(vector & v){std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_end_of_storage, v._end_of_storage);}//// 容量相关void reserve(size_t n){if (n > capacity()){size_t oldsize = size();T* tmp = new T[n];if (size() != 0){for (size_t i = 0; i < oldsize; i++){tmp[i] = _start[i];//这种赋值，即使在vector这样的深拷贝中也不会出现问题}					   //因为它在这种情况下它会调用赋值重载//这种写法在深一层的拷贝就会出错，比如vector二维数组/*memcpy(tmp, _start, size()*sizeof(T));*/delete[] _start;}_start = tmp;_finish = _start + oldsize;_end_of_storage = _start + n;}}void resize(size_t n,const T& x=T()){//容量不够先扩容if (n > capacity()){reserve(n);}for (size_t i = size(); i < n; ++i){_start[i] = x;}_finish = _start + n;}size_t capacity()  const{return _end_of_storage - _start;}size_t size() const{return _finish - _start;}bool empty(){return _finish == _start;}///// 元素访问T& operator[](size_t pos){assert(pos < size());return _start[pos];}const T& operator[](size_t pos) const {assert(pos < size());return _start[pos];}T& front(){return *_start;}const T& front() const{return *_start;}T& back(){return *(_finish - 1);}const T& back() const {return *(_finish - 1);}~vector(){delete[] _start;_start = _finish = _end_of_storage = nullptr;}private:T* _start; //容量空间的首地址T* _finish;  // 指向有效数据的尾T* _end_of_storage;  //容量空间的尾地址};/// //// 对模拟实现的vector进行严格测试void TestVector1(){hdm::vector v1;hdm::vector v2(10, 5);int array[] = { 1, 2, 3, 4, 5 };hdm::vector v3(array, array + sizeof(array) / sizeof(array[0]));hdm::vector v4(v3);for (size_t i = 0; i < v2.size(); ++i){cout << v2[i] << " ";}cout << endl;auto it = v3.begin();while (it != v3.end()){cout << *it << " ";++it;}cout << endl;for (auto e : v4){cout << e << " ";}cout << endl;}void TestVector2(){hdm::vector v;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.push_back(5);cout << v.size() << endl;cout << v.capacity() << endl;cout << v.front() << endl;cout << v.back() << endl;cout << v[0] << endl;for (auto e : v){cout << e << " ";}cout << endl;v.pop_back();v.pop_back();for (auto e : v){cout << e << " ";}cout << endl;v.insert(v.begin(), 0);for (auto e : v){cout << e << " ";}cout << endl;v.erase(v.begin() + 1);for (auto e : v){cout << e << " ";}cout << endl;}
}

测试示例一

测试示例二