😎【博客主页：你最爱的小傻瓜】😎

🤔【本文内容：C++ vector 😍  】🤔

--------------------------------------------------------------------------------------------------------------------------------

在 C++ 的典籍长廊中，vector 恰似一位博闻强识的书吏。

它以动态舒展的卷轴承载万千元素，不必忧虑篇幅局促 —— 新添内容时，只需轻挥 push_back 的笔墨，便有宣纸自然延展开来。那些沉睡的元素，如经卷中的字句般静候翻阅，用下标轻轻一点，便能唤醒某页某行的深意。

当你执迭代器之笔漫溯其间，如同指尖抚过古籍的竹笺，每一个元素都按序铺陈，静待细品。若想为这卷帙重整篇章，sort 函数便是最好的校勘师，转瞬便能将凌乱的字句编排得井然有序。

无论是数字的珠玑、字符的墨韵，还是自定义对象的锦绣文章，它都能妥帖收纳，恰似一座随需而建的藏书楼，让数据在其间各安其位，静待编程者翻阅取用。

---------------------------------------------------------------------------------------------------------------------------------在开始学习vector容器前，我们先要了解vector的概念：

( 一 ) vector 的介绍：

1. vector 是可变大小数组的序列容器。它具备数组采用的连续存储空间来存储元素的特性，又优化了数组无法动态改变大小的缺点。而对于vector容器的动态分配数组，是一个有利也有弊的处理方式。当我们插入新的数据时，且vector容器需要增加存储空间。这时他会重新开一个适合的数组来将原先的数组的数据赋值过去。而这里就有一个耗时的缺点。为了应对它，不同的库会有不同的分配空间策略：（核心）

//vector()
vector<int>v;

//vector (size_type n, const value_type& val = value_type())
vector<int>v(10,1); 

// vector (const vector& x);
vector<int> v1{1, 2, 3};
vector<int> v2(v1);

// vector (InputIterator first, InputIterator last);
// 示例1：用数组迭代器构造
int arr[] = {1, 2, 3, 4, 5};
vector<int> v(arr, arr + 5);
// 示例2：用vector的部分迭代器构造
vector<int> v1{1, 2, 3, 4, 5};
vector<int> v2(v1.begin() + 1, v1.end() - 1);

// begin + end（iterator 示例，可修改元素）
vector<int> v{1, 2, 3, 4, 5};
for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {*it *= 2; // 修改元素值
}
// begin + end（const_iterator 示例，只读）
vector<int> v1{1, 2, 3, 4, 5};
for (vector<int>::const_iterator cit = v1.cbegin(); cit != v1.cend(); ++cit) {cout << *cit << " "; // 只能读取元素值，不可修改
}

// rbegin + rend（reverse_iterator 示例）
vector<int> v{1, 2, 3, 4, 5};
for (vector<int>::reverse_iterator rit = v.rbegin(); rit != v.rend(); ++rit) {cout << *rit << " "; // 从后往前遍历并输出元素
}

vector<int> v{1, 2, 3, 4, 5};
cout << "数据个数：" << v.size() << endl;

vector<int> v;
v.push_back(1);
cout << "容量大小：" << v.capacity() << endl;

vector<int> v;
if (v.empty()) {cout << "vector 为空" << endl;
} else {cout << "vector 不为空" << endl;
}

// resize 示例1：新 size 大于原 size，用默认值填充
vector<int> v{1, 2, 3};
v.resize(5);
for (int num : v) {cout << num << " "; // 输出：1 2 3 0 0
}
cout << endl;
// resize 示例2：新 size 大于原 size，用指定值填充
vector<int> v1{1, 2, 3};
v1.resize(5, 10);
for (int num : v1) {cout << num << " "; // 输出：1 2 3 10 10
}
cout << endl;
// resize 示例3：新 size 小于原 size
vector<int> v2{1, 2, 3, 4, 5};
v2.resize(3);
for (int num : v2) {cout << num << " "; // 输出：1 2 3
}

vector<int> v;
v.reserve(10); // 提前分配能容纳 10 个元素的空间
cout << "容量大小：" << v.capacity() << endl;

vector<int> v;
v.push_back(1);
v.push_back(2);
// 此时v中的元素为[1, 2]

vector<int> v{1, 2, 3};
v.pop_back();
// 此时v中的元素为[1, 2]

vector<int> v{1, 3, 4};
// 在第二个元素位置（值为3的位置）前插入2
v.insert(v.begin() + 1, 2);
// 此时v中的元素为[1, 2, 3, 4]

vector<int> v{1, 2, 3, 4};
// 删除第三个元素（值为3的元素）
v.erase(v.begin() + 2);
// 此时v中的元素为[1, 2, 4]

vector<int> v{10, 20, 30};
cout << v[0] << " " << v[1] << " " << v[2] << endl; // 输出：10 20 30
v[1] = 25;
cout << v[1] << endl; // 输出：25

namespace xin
{template<class T >class vector{public:typedef T* iterator;            //常规的迭代器，可以读写typedef const T* const_iterator;//const修饰的迭代器，只能读无法写。//模拟实现    private:iterator _start = nullptr;      //指向vector开头的数据iterator _finish = nullptr;     //指向vector最后一个的数据iterator endofstorage = nullptr;//指向vector存储空间最后的位置};
};

vector()
{}

~vector()
{if (_start){delete[] _start;_start = _finish = _endofstorage = nullptr;}
}

//迭代器的访问方式：
iterator begin()//可读写，且在函数内部能进行修改所属对象。
{return _start;//返回头指针
}
iterator end()
{return _finish;//返回指向vector最后一个的数据的指针
}
const_iterator begin()const//1.只能读取容器中的元素，不能修改元素的值。2.在该函数内部，不能修改所属对象
{return _start;
}
const_iterator end()const
{return _finish;
}

size_t size()const //加这个const是为了在该函数内部，不能修改所属对象。
{return _finish - _start;//这里用指针减指针的方式来计算数据的个数
}

size_t capacity()const//加这个const是为了在该函数内部，不能修改所属对象
{return _endofstorage - _start;//这里用指针减指针的方式来计算存储空间的大小
}

void reserve(size_t n)
{if (n > capacity())//扩容的条件。{size_t sz = size();//计算原数组的数据大小T* tmp = new T[n];//申请新的数组//memcpy(tmp, _start, sizeof(T) * sz);//这里为什么不用 memcpy来将原先的数据赋值给新建的数组，是因为深拷贝的问题 兼容自定义类型的深拷贝需求 for (int i = 0;i < sz;i++)//for循环的更安全可靠。{tmp[i] = _start[i];}delete[] _start;//将这些指针给调到适合的位置。_start = tmp;_finish = _start + sz;_endofstorage = _start + n;}
}

void resize(size_t n, const T& val = T())//T()是指确保生成一个符合 “默认初始化” 语义的 T 类型对象。
{if (n < size()){_finish = _start + n;//（比size()小时，我们直接截取到我们想要的n个数据）}else{reserve(n);while (_finish != _start + n)//比size()大时，我们就重新申请空间，在将后面的空间赋值T(){*_finish = val;++finish;}}
}

iterator insert(iterator pos, const T& x)
{assert(pos >= _start && pos <= _finish);//判断pos是否在数组内if (_finish == _endofstorage)//判断两种请况：空 ，两个不同概念的尾部指针重合.以及处理方式。{size_t len = pos - _start;//为处理迭代器失效而留下的坐标。size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;reserve(new_capacity);pos = _start + len;//解决迭代器失效的问题}iterator end = _finish - 1;//这里减一是为了更好的访问和挪移数据。while (end > pos)//往后挪移{*(end + 1) = *end;--end;}//插入数据*pos = x;++_finish;return pos;
}

void push_back(const T& x)//尾插
{/*if (_finish == _endofstorage)//判断数据情况，如容器是否为空，为空的处理方式，不为空的处理方式。{size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;reserve(newcapacity);}//尾插。*_finish = x;++_finish;*/insert(end(),x);
}

10.构造函数和拷贝构造函数：

vector(size_t n, const T& val = T())//这里的构造就像当于截取，但因为是初始化，刚开始_start = _finish,所以他是从开头赋值初始化
{resize(n, val);
}
vector(int n, const T& val = T())//这个是因为当我们在传参的时有我们传<int int>时，编译器会更具“精确匹配优先于需要隐式转换的匹配”，会到迭代器哪里但int又不是迭代器，所以会报错。
{resize(n, val);
}
template<class InputIterator>
vector(InputIterator first, InputIterator last)//对于迭代器的初始化，而这里为什么用push_back呢，这是因为当我们不知道你要存储的数据大小时，我们只能一个一个填下去，尽管他是会遇到vector的这一缺点但还是要这样做，因为不知道有大小。
{while (first != last){push_back(*first);//因为刚开始_start = _finish。++first;}
}vector(const vector<T>& v)
{_start = new T[v.capacity()];//拷贝构造，申请空间//memcpy(_start,v._start,sizeof(T)*v.size);//是因为不适合自定义类形，浅拷贝与深拷贝的问题for (size_t i = 0;i < v.size();i++){_start[i] = v._start[i];}//为其赋值。_finish = _start + v.size();_endofstorage = _start + v.capacity();
}
//旧版
/*vector(const vector<T>& v):_start(nullptr), _finish(nullptr), _endofstorage(nullptr){reserve(v.capacity());for (auto e : v){push_back(e);}}*/

这里有一个概念要拿出来讲：

那便是精确匹配优先于需要隐式转换的匹配

对于：

vector<int>v(10，1);

你认为会用哪构造（如果没有int这个显示的），是size_t, 还模板的那个。他会是模板那个。因为编译器会把10，1都看成int，满足InputIterator first, InputIterator last的参数类型要求（两个参数类型相同）因此它符合精确匹配优先于需要隐式转换的匹配。而int —》size_t这个隐式转换优先级低。

解决方法：

核心就是不让它隐式转换。

1.外：

vector <int> v(10u, 1);

2.内：

vector(int n, const T& value = T())
{resize(n, value);
}

11.erase（删除pos位置数据）：

iterator erase(iterator pos)
{assert(pos >= _start && pos <= _finish);//判断pos是否在数组内iterator it = pos + 1;//这里加一是为了更好的访问和挪移数据while (it != _finish)//往前覆盖{*(it - 1) = *it；++it;}--_finish;return pos;
}

迭代器失效的定义与标准规定

对 vector 执行 erase(pos) 后，被删除元素的迭代器 pos 及其之后的所有迭代器都会失效。此时对失效迭代器进行解引用（如 *it）或递增（如 ++it）操作，属于未定义行为（标准不规定执行结果，编译器可自由处理，可能崩溃、输出错误结果甚至 “看似正常运行”）。

不同平台的表现差异

• VS：对迭代器有效性做严格额外检查，若检测到使用失效迭代器，会直接报错或崩溃，能提前暴露问题。
• Linux：默认不做强制检查，失效迭代器可能恰好指向未回收内存，导致程序 “看似能运行”，但这是巧合，本质仍为错误代码。

错误代码示例与问题

 // 错误示例：删除所有偶数for (auto it = v.begin(); it != v.end(); ++it) {if (*it % 2 == 0) {v.erase(it); // 删除后，it已失效// 此处it指向被删除元素的下一个位置，但标准未定义其有效性}}// 输出结果可能异常（如跳过元素、循环提前结束等）for (int num : v) {cout << num << " ";}return 0;

如删除偶数的代码（erase 后直接 ++it），会因迭代器失效出现逻辑错误（如跳过元素），且删除本质是移动数据覆盖待删数据，会导致 finish 前移，后续 it 可能永远不等于 end，循环无法正确结束。

看似 “可行” 代码的隐患

即使在 Linux 下 “通过测试” 的代码，也存在问题：

• 不符合 C++ 标准，erase(it) 后 it 已失效，后续 it != v.end() 判断也可能出错。
• 移植性极差，换用 VS 等编译器或调试模式会暴露崩溃 / 逻辑错误。
• 若触发扩容（内存重分配），失效 it 指向旧内存块，操作会导致严重错误。

正确做法

vector 删除元素时，必须通过 erase 的返回值更新迭代器，这是唯一能保证跨平台一致性和程序正确性的做法。其他 “看似可行” 的写法，本质是依赖未定义行为的侥幸，隐藏着难以排查的风险。判断代码正确性，应看是否符合语言标准，而非 “在某平台能运行”。

12.尾删：

void pop_back()
{erase(--end());
}

直接用erase任意位置删除，如果不想用erase也可以在erase里面的代码里找删除的原理再套用在尾部。

13.重载：

void swap(vector<T>& v)
{std::swap(_start, v._start);std::swap(_finish, v._finish);std::swap(_endofstorage, v._endofstorage);
}// v1 = v2
vector<T>& operator=(vector<T> v)
{swap(v);return *this;
}
T& operator[](size_t pos)
{assert(pos < size());return _start[pos];
}const T& operator[](size_t pos) const
{assert(pos < size());return _start[pos];
}

这里的重载都与strin类里面的类似。主要是swap这个交换，以及对_start指针的运用。

完整代码：

#include<assert.h>
#include<string>
#include<iostream>
using namespace std;
namespace xin
{template<class T >class vector{public:typedef T* iterator;            //常规的迭代器，可以读写  typedef const T* const_iterator;//const修饰的迭代器，只能读无法写。//析构函数：~vector(){if (_start){delete[] _start; //从头指针开始找 释放空间_start = _finish = _endofstorage = nullptr; //将指针赋值为空}}//迭代器的访问方式：iterator begin()//可读写，且在函数内部能进行修改所属对象。{return _start;//返回头指针}iterator end()//可读写，且在函数内部能进行修改所属对象。{return _finish;//返回指向vector最后一个的数据的指针}const_iterator begin()const//1.只能读取容器中的元素，不能修改元素的值。2.在该函数内部，不能修改所属对象{return _start;}const_iterator end()const//1.只能读取容器中的元素，不能修改元素的值。2.在该函数内部，不能修改所属对象{return _finish;}size_t size()const //加这个const是为了在该函数内部，不能修改所属对象。{return _finish - _start;//这里用指针减指针的方式来计算数据的个数}size_t capacity()const//加这个const是为了在该函数内部，不能修改所属对象{return _endofstorage - _start;//这里用指针减指针的方式来计算存储空间的大小}void reserve(size_t n){if (n > capacity())//扩容的条件。{size_t sz = size();//计算原数组的数据大小T* tmp = new T[n];//申请新的数组//memcpy(tmp, _start, sizeof(T) * sz);//这里为什么不用 memcpy来将原先的数据赋值给新建的数组，是因为深拷贝的问题 兼容自定义类型的深拷贝需求 for (int i = 0;i < sz;i++)//for循环的更安全可靠。{tmp[i] = _start[i];}delete[] _start;//将这些指针给调到适合的位置。_start = tmp;_finish = _start + sz;_endofstorage = _start + n;}}void resize(size_t n, const T& val = T())//T()是指确保生成一个符合 “默认初始化” 语义的 T 类型对象。{if (n < size()){_finish = _start + n;//（比size()小时，我们直接截取到我们想要的n个数据）}else{reserve(n);while (_finish != _start + n)//比size()大时，我们就重新申请空间，在将后面的空间赋值T(){*_finish = val;++finish;}}}iterator insert(iterator pos, const T& x){assert(pos >= _start && pos <= _finish);//判断pos是否在数组内if (_finish == _endofstorage)//判断两种请况：空 ，两个不同概念的尾部指针重合.以及处理方式。{size_t len = pos - _start;//为处理迭代器失效而留下的坐标。size_t new_capacity = capacity() == 0 ? 4 : capacity() * 2;reserve(new_capacity);pos = _start + len;//解决迭代器失效的问题}iterator end = _finish - 1;//这里减一是为了更好的访问和挪移数据。while (end > pos)//往后挪移{*(end + 1) = *end;--end;}//插入数据*pos = x;++_finish;return pos;}void push_back(const T& x)//尾插{if (_finish == _endofstorage)//判断数据情况，如容器是否为空，为空的处理方式，不为空的处理方式。{size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;reserve(newcapacity);}//尾插。*_finish = x;++_finish;insert(_finish, x);}vector(size_t n, const T& val = T())//这里的构造就像当于截取，但因为是初始化，刚开始_start = _finish,所以他是从开头赋值初始化{resize(n, val);}vector(int n, const T& val = T())//这个是因为当我们在传参的时有我们传<int int>时，编译器会更具“精确匹配优先于需要隐式转换的匹配”，会到迭代器哪里但int又不是迭代器，所以会报错。{resize(n, val);}template<class InputIterator>vector(InputIterator first, InputIterator last)//对于迭代器的初始化，而这里为什么用push_back呢，这是因为当我们不知道你要存储的数据大小时，我们只能一个一个填下去，尽管他是会遇到vector的这一缺点但还是要这样做，因为不知道有大小。{while (first != last){push_back(*first);//因为刚开始_start = _finish。++first;}}vector(const vector<T>& v){_start = newT[v.capacity];//拷贝构造，申请空间//memcpy(_start,v._start,sizeof(T)*v.size);//是因为不适合自定义类形for (size_t i = 0;i < v.size;i++){_start[i] = v._start[i];}//为其赋值。_finish = _start + v.size;_endofstorage = _start + v.capacity;}iterator erase(iterator pos){assert(pos >= _start && pos <= _finish);//判断pos是否在数组内iterator it = pos + 1;//这里加一是为了更好的访问和挪移数据while (it != _finish)//往前覆盖{*(it - 1) = *it；++it;}--_finish;return pos;}void swap(const vector<T>& v){_start = v._start;_finish = v._finish;_endofstorage = v._endofstorage;}vector<T>& operator=(vector<T>& v){swap(v);return *this;}T& operator [](size_t pos){assert(pos < size());return _start[pos];}const T& operator [](size_t pos)const{assert(pos < size());return _start[pos];}private:iterator _start = nullptr;      //指向vector开头的数据iterator _finish = nullptr;     //指向vector最后一个的数据iterator _endofstorage = nullptr;//指向vector存储空间最后的位置};
};

❤️总结

相信坚持下来的你一定有了满满的收获。那么也请老铁们多多支持一下，为爱博，点点举报，偶布，是点点关注，收藏，点赞。❤️