今日分享:C++ -- vector

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

🤔【本文内容：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存储空间最后的位置
	};
};

❤️总结

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