C++ vector类操作全解析（含模拟实现）

1.vector的介绍及使用

[1.1 vector的介绍](#1.1 vector的介绍)

[1.2 vector的使用](#1.2 vector的使用)

2.vector深度剖析及模拟实现

（5）vector的构造、拷贝构造、析构、赋值重载

如果大家对C++的学习感兴趣，欢迎来观摩下本人的总结专栏：

C++语法专栏：

https://blog.csdn.net/2302_79440910/category_13027387.html

数据结构专栏：

https://blog.csdn.net/2302_79440910/category_13026083.html

1.vector的介绍及使用

1.1 vector的介绍

vector是表示可变大小数组的序列容器。
就像数组一样，vector也采用的连续存储空间 来存储元素。也就是意味着可以采用下标对vector的元素进行访问 ，和数组一样高效。但是又不像数组，它的大小是可以动态改变 的，而且它的大小会被容器自动处理。
本质上讲，vector使用动态分配数组 来存储它的元素。当新元素插入时候，为了增加存储空间，这个数组需要被重新分配大小。其做法是，分配一个新的数组，然后将全部元素移到这个数组。 就时间而言，这是一个相对代价高的任务，因此每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
vector分配空间策略：vector会分配一些额外的空间 以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list 统一的迭代器和引用更好。

1.2 vector的使用

1.2.1 vector的定义

代码示例：

cpp 复制代码

#include <iostream>
#include <vector>

int main() {
    // 1. 无参构造 (vector())
    std::vector<int> v1;
    std::cout << "v1 size: " << v1.size() << ", capacity: " << v1.capacity() << "\n";

    // 2. 带初始值构造 (vector(size_type n, const value_type& val))
    std::vector<int> v2(5, 10); // 构造包含5个10的向量
    std::cout << "v2 elements: ";
    for (int num : v2) std::cout << num << " "; 
    std::cout << "\n";

    // 3. 拷贝构造 (vector(const vector& x))
    std::vector<int> v3(v2); // 复制v2的内容
    std::cout << "v3 elements: ";
    for (int num : v3) std::cout << num << " "; 
    std::cout << "\n";

    // 4. 迭代器区间构造 (vector(InputIterator first, InputIterator last))
    int arr[] = {20, 30, 40};
    std::vector<int> v4(arr, arr + 3); // 从数组arr构造
    std::cout << "v4 elements: ";
    for (int num : v4) std::cout << num << " "; 
    std::cout << "\n";

    return 0;
}

1.2.2 vector iterator 的使用

迭代器有点类似于指针但又不是指针；除了下标遍历vector以外，还可以用迭代器和范围for：

cpp 复制代码

#include <iostream>
#include <vector>

int main() {
    // 创建一个vector并初始化
    std::vector<int> vec = {10, 20, 30, 40, 50};
    
    // 1. 使用普通迭代器遍历
    std::cout << "使用普通迭代器遍历: ";
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    // 2. 使用const_iterator遍历（适用于只读场景）
    std::cout << "使用const_iterator遍历: ";
    for (std::vector<int>::const_iterator cit = vec.cbegin(); cit != vec.cend(); ++cit) {
        std::cout << *cit << " ";
    }
    std::cout << std::endl;
    
    // 3. 使用auto关键字简化迭代器声明（C++11及以上）
    std::cout << "使用auto简化迭代器: ";
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    
    // 4. 使用基于范围的for循环（C++11及以上，推荐方式）
    std::cout << "使用范围for循环: ";
    for (const auto& value : vec) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    
    // 5. 使用反向迭代器遍历（从后向前）
    std::cout << "使用反向迭代器: ";
    for (std::vector<int>::reverse_iterator rit = vec.rbegin(); rit != vec.rend(); ++rit) {
        std::cout << *rit << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

1.2.3 vector 空间增长问题

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

接下来，我们对resize和reserve进行讨论：

1.reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问题。且开辟的空间大小必须大于当前空间容量；即：

reserve函数用于预分配内存空间，但不改变容器中实际的元素数量：

reserve会增加容器的capacity()，确保有足够的内存空间
它不会改变size()的值，也不会添加或删除元素，因此扩容后不要盲目使用下标访问，最好使用push_back;

代码样例：

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v;
    
    // 预留容量为10（不改变size）
    v.reserve(10);
    cout << "reserve(10)后：size=" << v.size() << ", capacity=" << v.capacity() << endl; // 输出：size=0, capacity=10
    
    // 插入元素（不会频繁扩容）
    for (int i = 0; i < 15; i++) {
        v.push_back(i);
    }
    cout << "插入15个元素后：size=" << v.size() << ", capacity=" << v.capacity() << endl; // 输出：size=15, capacity=20（通常按倍数增长）
    return 0;
}

resize函数用于改变容器的大小（即元素的个数）。对于string和vector：

当新的大小大于当前大小时，resize会添加默认构造的元素到容器中
当新的大小小于当前大小时，resize会移除多余的元素
resize会影响容器的size()返回值，同时可能改变capacity()

代码样例：

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3}; // 初始size=3，capacity≥3
    
    // 扩大size到5（新增元素用0填充）
    v.resize(5);
    cout << "resize(5)后：";
    for (int num : v) cout << num << " "; // 输出：1 2 3 0 0
    
    // 缩小size到2（删除多余元素）
    v.resize(2);
    cout << "\nresize(2)后：";
    for (int num : v) cout << num << " "; // 输出：1 2
    return 0;
}

1.2.3 vector 增删查改

下面的代码包含了这些接口的使用：

cpp 复制代码

#include <iostream>
#include <vector>
#include <algorithm> // 用于find算法

int main() {
    // 1. push_back: 尾插
    std::vector<int> vec;
    vec.push_back(10); // 在末尾添加10
    vec.push_back(20); // 在末尾添加20
    vec.push_back(30); // 在末尾添加30
    std::cout << "push_back后: ";
    for (int num : vec) std::cout << num << " "; // 输出: 10 20 30
    std::cout << std::endl;

    // 2. pop_back: 尾删
    vec.pop_back(); // 移除最后一个元素(30)
    std::cout << "pop_back后: ";
    for (int num : vec) std::cout << num << " "; // 输出: 10 20
    std::cout << std::endl;

    // 3. find: 查找（算法模块实现）
    auto it = std::find(vec.begin(), vec.end(), 20); // 查找元素20
    if (it != vec.end()) {
        std::cout << "找到元素 " << *it << " 在位置 " << std::distance(vec.begin(), it) << std::endl; // 输出: 找到元素 20 在位置 1
    } else {
        std::cout << "未找到元素" << std::endl;
    }

    // 4. insert: 在position之前插入val
    vec.insert(vec.begin() + 1, 15); // 在位置1（原20的位置）前插入15
    std::cout << "insert后: ";
    for (int num : vec) std::cout << num << " "; // 输出: 10 15 20
    std::cout << std::endl;

    // 5. erase: 删除position位置的数据
    vec.erase(vec.begin()); // 删除第一个元素(10)
    std::cout << "erase后: ";
    for (int num : vec) std::cout << num << " "; // 输出: 15 20
    std::cout << std::endl;

    // 6. swap: 交换两个vector的数据空间
    std::vector<int> other_vec = {100, 200, 300};
    vec.swap(other_vec); // 交换vec和other_vec的内容
    std::cout << "swap后vec: ";
    for (int num : vec) std::cout << num << " "; // 输出: 100 200 300
    std::cout << "\nswap后other_vec: ";
    for (int num : other_vec) std::cout << num << " "; // 输出: 15 20
    std::cout << std::endl;

    // 7. operator[]: 像数组一样访问
    std::cout << "operator[]访问: vec[0] = " << vec[0] << ", vec[1] = " << vec[1] << std::endl; // 输出: vec[0] = 100, vec[1] = 200

    return 0;
}

其中，find是算法模块实现的，可以对任何有迭代器的容器使用，对普通数组也能用，只不过要自己提供数组的迭代器：

cpp 复制代码

#include <algorithm>
#include <iostream>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int value = 3;
    
    // 使用find查找数组中的值
    int* result = std::find(std::begin(arr), std::end(arr), value);
    
    if (result != std::end(arr)) {
        std::cout << "找到值 " << value << " 在位置 " << result - arr << std::endl;
    } else {
        std::cout << "未找到值 " << value << std::endl;
    }
    
    return 0;
}

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

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

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

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

cpp 复制代码

#include <iostream>
using namespace std;
#include <vector>

int main()
{
    vector<int> 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);
    
   
    while(it != v.end())
    {
        cout<< *it << " " ;
        ++it;
    }
    cout<<endl;
    return 0;
}

我们分析一下迭代器为何会失效：以上操作，都可能会使vector扩容，一旦扩容，vector会重新分配一块新的内存空间，然后将旧空间内的数据拷贝过来，并释放掉旧空间，但是由于我们在扩容前就定义了迭代器it，所以扩容后，这个迭代器仍然是指向旧空间的，旧空间被释放，迭代器就失效了，再去用这个迭代器就会程序崩溃。

解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给it重新赋值即可。

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

下面给出迭代器失效的示例：

cpp 复制代码

#include <iostream>
using namespace std;
#include <vector>
 
int main()
{
 int a[] = { 1, 2, 3, 4 };
 vector<int> v(a, a + sizeof(a) / sizeof(int));
 
 // 使用find查找3所在位置的iterator
 vector<int>::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就认为该位置迭代器失效了。

以下代码的功能是删除vector中所有的偶数，请问那个代码是正确的，为什么？

cpp 复制代码

#include <iostream>
using namespace std;
#include <vector>
 
int main()
{
 vector<int> v{ 1, 2, 3, 4 };
 auto it = v.begin();
 while (it != v.end())
 {
 if (*it % 2 == 0)
 v.erase(it);
 
 ++it;
 }
 
 return 0;
}
 
int main()
{
 vector<int> v{ 1, 2, 3, 4 };
 auto it = v.begin();
 while (it != v.end())
 {
 if (*it % 2 == 0)
 it = v.erase(it);
 else
 ++it;
 }
 
 return 0;
}

答案是第二种正确，因为在遍历到偶数的时候，调用erase删除这个位置的元素后，会使迭代器失效，因此需要重新对此迭代器赋值即可！

与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效。

2.vector深度剖析及模拟实现

（1）vector的基本框架构成

cpp 复制代码

#include <iostream>
#include <algorithm>
#include <assert.h>
using namespace std;

namespace myvector
{
	template<class T>
	class Vector
	{
	public:
		using iterator = T*;
		using const_iterator = const T*;
		

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;

	};
}

vector底层维护了三个指针，_start指向首元素，_finish指向末尾元素的后一个位置，_end_of_storage指向整个容量空间的后一个位置；在vector没有分配空间时，我们将这三个指针默认为nullptr即可；不过要注意：类内初始化的优先级低于构造函数和初始化列表，这意味着如果同时使用这三种方式，构造函数中的初始化会覆盖类内初始化的值。

另外，string和vector的迭代器我们都认为是指针，因此迭代器的实现也比较简单

cpp 复制代码

const_iteraor begin()const
{
	return _start;
}
const_iteraor end()const
{
	return _finish;
}

（2）vector的简单接口实现：

a.vector的交换功能

cpp 复制代码

void swap(Vector& v)
{
	swap(_start, v._start);
	swap(_finish, v._finish);
	swap(_end_of_storage, v._end_of_storage);
}

b.尾删的实现

cpp 复制代码

void pop_back()
{
	assert(size() > 0);
	_finish--;
}

c.下标重载

cpp 复制代码

T& operator[](int pos)
{
	assert(pos >= 0 && _start + pos < _finish);
	return _start[pos];
}

d.容量相关操作

cpp 复制代码

int capacity()const
{
	return _end_of_storage - _start;
}
int size()const
{
	return _finish - _start;
}

（3）reserve的实现

cpp 复制代码

void reserve(int n)
{
	if (n > capacity())
	{
		T* tmp = new T[n];
		int oldsize = size();
		//memcpy(tmp, _start, sizeof(T) * size());
		for (int i = 0; i < oldsize; i++)
		{
			tmp[i] = _start[i];
		}
		delete[]_start;
		_start = tmp;
		_finish = _start + oldsize;
		_end_of_storage = _start + n;
	}
}

这个接口是很重要的，因为vector的扩容和预留空间都是靠它实现的。

它的思路：如果n大于当前容量，就执行后续操作：首先申请大小为n的空间，再去得到旧空间的有效元素个数，通过下标访问【】依次拷贝进来，这样就完成了深拷贝，将旧空间释放掉，然后让三个指针指向新空间的对应位置；

假设模拟实现的vector中的reserve接口中，使用memcpy进行的拷贝，代码会发生什么问题？

问题分析：

memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

所以，如果我们如果采用memcpy来拷贝，那么在vector扩容的时候，就是对旧空间的数据进行了浅拷贝，新旧空间指向的是同一片空间，那么当旧空间释放后，新空间指向的就是一块已经被释放的空间，会引起程序崩溃！

结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。

（4）尾插的实现

cpp 复制代码

void push_back(const T& x)
{
	if (_finish == _end_of_storage)
	{
		int newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}
	*_finish++ = x;
}

注意尾插之前要检查扩容！

（5）vector的构造、拷贝构造、析构、赋值重载

vector的构造有很多种，包括默认构造、初始化列表构造、迭代器构造等

**a.默认构造：**默认构造就是要产生一个空的vector，还记得我们在类内对三个指针的初始化吗？如果没有默认构造，这三个指针是不会赋值nullptr的，因此要强制生成默认构造

cpp 复制代码

Vector() = default;

b.初始化列表构造：

cpp 复制代码

Vector(initializer_list<T> v)
{
	int sz = v.size();
	reserve(sz);
	for (auto& e : v)
	{
		push_back(e);
	}
}

为了避免反复扩容导致的开销，我们要预先对vector扩充出预期的空间大小，然后遍历列表元素依次尾插进来即可。

c.迭代器构造

cpp 复制代码

template<class Inputinitial>
Vector(Inputinitial first, Inputinitial end)
{
	while (first != end)
	{
		push_back(*first);
		first++;
	}
}

vector应该能接受所有类型的迭代器构造，因此我们要引入迭代器的模版参数Inputinitial，这个参数可以接受任意类型的迭代器，然后具象化到函数中。

d.其他构造

cpp 复制代码

	Vector(int n, const T& x = T())
	{
		reserve(n);
		for (int i = 0; i < n; i++)
		{
			push_back(x);
		}
	}

这种构造是给vector赋值n个相同的元素，元素值默认是空（对于整形来说就是0）；

思路：预留空间+尾插元素

e.拷贝构造

cpp 复制代码

	Vector(const Vector& v)
	{
		reserve(v.size());
		for (auto& e : v)
		{
			push_back(e);
		}
	}

思路：预留空间+尾插元素

f.赋值重载

cpp 复制代码

Vector& operator=(Vector v)
{
	if (this != &v)
	{
		swap(v);
	}
}

注意这里的形参不是引用，所以只是一份临时拷贝，我们直接将这个临时拷贝的对象的内容全部交换过来即可，就不用深拷贝那么麻烦了。

g.析构函数

cpp 复制代码

~Vector()
{
	if (_start)
	{
		delete[] _start;
		_start = _finish = _end_of_storage = nullptr;
	}
}

（6）指定位置插入、删除

insert：

cpp 复制代码

iterator insert(iterator pos, const T& x)
{
	if (_finish == _end_of_storage)
	{
		int len = pos - _start;
		int newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
		pos = _start + len;
	}
	for (iterator it = _finish; it > pos; it--)
	{
		*it = *(it - 1);
	}
	*pos = x;
	_finish++;
	return pos;
}

思路：插入之前要先检查扩容，如果需要扩容，还要注意扩容之后旧空间会被释放掉，那么pos迭代器也就失效了，所以我们要重新对pos赋值，让它指向新空间；然后将pos后面的元素全部向右移一位，就可以插入数据了；

erase：

cpp 复制代码

iterator erase(iterator pos)
{
	assert(size() > 0);
	assert(pos >= _start && pos < _finish);
	for (iterator it = pos; it < _finish; it++)
	{
		*it = *(it + 1);
	}
	_finish--;
	return pos;
}

思路：删除前先检查是否有剩余元素，以及pos迭代器的合法性；然后将pos右边的元素向左移一位，更新_finish--即可；

注意：由于pos可能位于最后一个元素，这样元素移动之后pos就是end迭代器，没有元素，就失效了，因此erase之后pos迭代器会失效，而insert不会，因为insert在过程中更新了pos迭代器。

（6）动态二维数组理解

cpp 复制代码

// 以杨慧三角的前n行为例：假设n为5
void test2vector(size_t n)
{
 // 使用vector定义二维数组vv，vv中的每个元素都是vector<int>
 bit::vector<bit::vector<int>> vv(n);
 
 // 将二维数组每一行中的vecotr<int>中的元素全部设置为1
 for (size_t i = 0; i < n; ++i)
 vv[i].resize(i + 1, 1);
 
 // 给杨慧三角出第一列和对角线的所有元素赋值
 for (int i = 2; i < n; ++i)
 {
 for (int j = 1; j < i; ++j)
 {
 vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
 }
 }
}

bit::vector> vv(n); 构造一个vv动态二维数组，vv中总共有n个元素，每个元素都是vector类型的，每行没有包含任何元素，如果n为5时如下所示：

如果想具体分配二维空间，可以这样：vector<vector<int>>vv(5,vector<int>(5,1);

这样分配出来就是5行5列都为1的二维空间；