vector(c++)

于 2025-05-17 17:16:40 发布
阅读量849 收藏 23
点赞数 13
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kukubuzai/article/details/148027606
版权

前言

正式进入学习STL的第一步就是vector容器， vector是一种用于存储可变大小数组的序列容器，就像数组一样，vector也采用的连续存储空间来存储元素。本质上讲，vector使用动态分配数组来存储它的元素。底层是一个顺序表。本文介绍的是gcc使用的STL源码的vector容器，这也是业界比较认可的一种STL版本。后续的vector模拟实现一切都是向这个版本靠齐。

正文

vector使用

class Print
{
public:
	template<class T>
	static void printVector(vector<T> v)
	{
		for (auto e : v)
		{
			cout << e << " ";
		}
	}
};

这里我先把打印封装成一个类，方便后序测试的打印

vector的定义

vector::vector - C++ Reference接口说明
vector()（重点）无参构造
vector（size_type n, const value_type& val = value_type()）构造并初始化n个val
vector (const vector& x); （重点）拷贝构造
vector (InputIterator first, InputIterator last);使用迭代器进行初始化构造

//vector的定义
void test01()
{
	//重点
	//初始化列表初始化(c++11特性) c++98不支持
	vector<int> v1 = { 1,2,3,4 };
	vector<int> v2(v1);
	Print::printVector(v1);
	cout << endl;
	Print::printVector(v2);
	cout << endl;
	vector<int> v3(10,-1);
	vector<int> v4(v1.begin(),v1.end());
	Print::printVector(v3);
	cout << endl;
	Print::printVector(v4);
}

这里着重掌握无参构造和拷贝构造，其他的了解即可

vector iterator 的使用

iterator的使用接口说明
begin + end（重点）获取第一个数据位置的iterator/const_iterator， 获取最后一个数据的下一个位置 的iterator/const_iterator
rbegin + rend获取最后一个数据位置的reverse_iterator，获取第一个数据前一个位置的 reverse_iterator

//vector iterator 的使用
//正向迭代器和反向迭代器
void test02()
{
	vector<int> v1 = { 1,2,3,4 };
	vector<int> v2(v1);
	vector<int>::iterator it1 = v1.begin();
	while (it1 != v1.end())
	{
		cout << *it1 << " ";
		it1++;
	}
	cout << endl;
	auto it2 = v2.rbegin();
	while (it2 != v2.rend())
	{
		cout << *it2 << " ";
		it2++;

	}

}

这里的迭代器没啥好说的，会使用就行，不过要注意迭代器失效，下面会着重讲。

vector 容量

容量空间接口说明
size获取数据个数
capacity获取容量大小
empty判断是否为空
resize（重点）改变vector的size
reserve （重点）改变vector的capacity 

//vector 容量
void test03()
{
	vector<int> v1 = { 1,2,3,4 };
	vector<int> v2(v1);
	//重点
	Print::printVector(v2);
	cout << endl;
	//大于size()
	v2.resize(10, -1);
	Print::printVector(v2);
	cout << endl;
	//小于size()
	v2.resize(3, -1);
	Print::printVector(v2);
	cout << endl;
	//size capacity empty
	size_t size = v1.size();
	size_t capacity = v1.capacity();
	cout << "v1: " << size << " " << capacity << " " << (v1.empty() ? "true" : "false") << endl;
	
}

和string的容量大差不差，会使用即可

vector 增删查改

vector 增删查改接口说明
push_back（重点）尾插
pop_back （重点）尾删
find查找。（注意这个是算法模块实现，不是vector的成员接口）
insert在position之前插入val
erase删除position位置的数据
swap交换两个vector的数据空间
operator[] （重点）像数组一样访问

//vector 增删查改
void test04()
{
	vector<int> v1;
	//重点
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	vector<int> v2(v1);
	v1.pop_back();
	cout << "v1:test: ";
	for (size_t i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << " ";
	}
	cout << endl;
	cout << "v2:test: ";
	for (size_t i = 0; i < v2.size(); i++)
	{
		cout << v2[i] << " ";
	}
	cout << endl;
	//find insert erase swap
	//...就不测试了 大家自己测试下吧 都是很简单的
}

这里的增删查改和string的差不多，不过要注意vector并没有find接口，这个接口是算法的接口，就是再一段区间找值并返回迭代器而已，很简单。

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

//vector 迭代器失效问题。（重点）
void test05()
{
	vector<int> v1 = { 1,2,3,4,5,6 };
	vector<int> v2(v1);
	auto it1 = v1.begin();
	while (it1 != v1.end())
	{
		if (*it1 % 2 == 0)
		{
			v1.erase(it1);
		}
		else
		{
			it1++;
		}
	}
	Print::printVector(v1);
	auto it2 = v2.begin();
	while (it2 != v2.end())
	{
		if (*it2 % 2 == 0)
		{
			it2 = v2.erase(it2);
		}
		else
		{
			it2++;
		}
	}
	Print::printVector(v2);
}

这里才是重点，要了解迭代器失效问题，就要先了解迭代器的原理底层，vector的迭代器底层本质还是指针实现的。所以指针就会涉及拷贝时的一个深浅拷贝，指针指向的地址的问题。由于是深拷贝，所以如果涉及到扩容，我们就会新开辟一块新空间，把原来的数据拷贝到这里。但是，迭代器还是指向原来空间的位置，原来的空间已经被释放掉，所以这里迭代器失效本质上就是一个野指针。那怎么解决这个问题呢？总不能不深拷贝吧？改变下参数吗？参数改变也没啥用呀。我erase是删除迭代器位置的数据，对你还要不要使用这个迭代器我没有义务保证你的安全呀？所以，我们对返回值做文章，返回要删除数据的下一个迭代器。这也是为啥insert会有一个返回值，返回插入位置的迭代器。

这里还涉及一个平台检查问题，下面这段代码在gcc下是可以编译通过的，但是在vs下直接报错

	vector<int> v1 = { 1,2,3,4,5,6 };
	auto it1 = v1.begin();
	while (it1 != v1.end())
	{
		if (*it1 % 2 == 0)
		{
			v1.erase(it1);
		}
		else
		{
			it1++;
		}
	}
	Print::printVector(v1);

因此，这里有一个结论，insert和erase之后我们一致认为你的迭代器是失效，使用它结果是未定义的。

vector的模拟实现

这里才是学习vector的重头戏，只有自己模拟实现一个vector，你才能正真理解这个容器的设计。

成员变量

private:
	T* _start = nullptr;
	T* _finish =nullptr;
	T* _endofstorage = nullptr;

为啥这里不是，size,capacity,_arr呢？咋是什么_finish？这是啥？其实这和STL的设计理念有关，这里从vector开始就几乎基本全面介入迭代器了。vector的迭代器底层就是T*。所以，他的变量要设计成这样也是为了向迭代器靠拢，_start就是数组的起始位置,_finish是 最后一个数据的下一个位置,_endifstorage就是容器的底部的下一个位置。这里我给了初始值(c++11打入的补丁)，所以后面构造函数我没有在初始化值了。

这里先实现下swap函数，方便后续函数的编写。

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}

默认成员函数

这里我使用的是直接new delete管理动态内存分配，但是原版STL使用的是空间配置器，其实底层还是包装new delete而已，但不过人家的这个空间配置器效率更高。对于我们初学者，先使用new delete就可以了，如果现在就要你学习空间配置器，让你掌握并使用。那可谓真的是从入门到放弃。一般来说空间配置器是c++很后面才会讲的。

构造 析构
vector()
{

}
vector(size_t n,const T& val = T())
{
	resize(n, val);
}
vector(int n, const T& val = T())
{
	resize(n, val);
}
//再套一个类模板
//相比上一个构造函数 匹配程度更高 和类型有关
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}

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

这里构造析构没啥坑，就是正常实现就行。

拷贝构造
	vector(const vector<T>& v)
	{
		_start = new T[v.capacity()];
		//memcpy(_start, v._start, sizeof(T) * v.size());
		//解决对象的深拷贝
		for (size_t i = 0; i < size(); i++)
		{
			_start[i] = v._start[i];
		}
		_finish = _start + v.size();
		_endofstorage = _start + v.capacity();
	}

这里是一个难点，主要是深拷贝的问题，对于内置类型的靠别没有问题。但是如果是自定义类型，使用memcpy就是一个浅拷贝。那如何解决呢？使用for循环，使用它们内部的赋值重载一个个赋值。

赋值重载
	vector<T>& operator=(vector<T> v)
	{
		swap(v);
		return *this;
	}

迭代器

这里我并没有实现反向迭代器

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;
}

容量操作

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_endofstorage = _start + n;
			}
		}
		//匿名对象当省略值 如果是内置类型 c++会特殊处理 升级成对象 调用无参构造
		void resize(size_t n, const T& val = T())
		{
			if (n < capacity())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
		}
		size_t size() const
		{
			return _finish - _start;
		}
		size_t capacity() const
		{
			return _endofstorage - _start;
		}
		bool empty()
		{
			return size() == 0;
		}

这里的扩容，和上面拷贝构造函数内部迭代器失效是一个原理，所以我们也要换一下拷贝，不能使用memcpy。

增删查改和访问引用操作

访问引用

	T& operator[](size_t pos)
	{
		assert(pos < size());
		return _start[pos];
	}
	const T& operator[](size_t pos) const
	{
		assert(pos < size());
		return _start[pos];
	}

增删查改

		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			iterator end = pos;
			while (end < _finish)
			{
				*end = *(end + 1);
				end++;
			}
			_finish--;
			return pos;
		}
		iterator erase(iterator first, iterator last)
		{
			assert(first >= _start && first <= _finish);
			assert(last >= _start && last <= _finish);
			assert(first <= _finish);
			iterator it1 = first, it2 = last;
			size_t len = last - first;
			//1 2 3 4 5
			while (it1 <= last)
			{
				*it1 = *(it2);
				it1++;
				it2++;
			}
			_finish -= len;
			return last;
		}
		void push_back(const T& x)
		{
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}
		void pop_back()
		{
			erase(--end());
		}
		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish); //等于就是尾插和头插
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
				//解决内部迭代器失效
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}

vector实现二维数组

实际上就是一个函数套一个函数而已，那这样岂不是效率很低，放心它会直接升级内联的。和c++讲效率低，你简直是在侮辱它？

void test06()
{
	vector<vector<int>> arr = { {1,},{1,2},{1,2,3} };
	//vector<vector<int>>
	for (auto e : arr)
	{
		//e : vector<int>
		for (auto i : e)
		{
			//i int
			cout << i << " ";
		}
		cout << endl;
	}
}

源码

#pragma once
#include <stdio.h>
#include <assert.h>
//vector insert和erase之后我们认为迭代器是失效的
//访问结果是未定义的
namespace che 
{
	template<class T>
	class vector
	{
	public:
		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()
		{

		}
		vector(size_t n,const T& val = T())
		{
			resize(n, val);
		}
		vector(int n, const T& val = T())
		{
			resize(n, val);
		}
		//再套一个类模板
		//相比上一个构造函数 匹配程度更高 和类型有关
		template<class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++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 < size(); i++)
			{
				_start[i] = v._start[i];
			}
			_finish = _start + v.size();
			_endofstorage = _start + v.capacity();
		}
		//其他写法
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endofstorage = nullptr;
			}
		}
		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);
		}
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);
					for (size_t i = 0; i < size(); i++)
					{
						tmp[i] = _start[i];
					}
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_endofstorage = _start + n;
			}
		}
		iterator erase(iterator pos)
		{
			assert(pos >= _start && pos < _finish);
			iterator end = pos;
			while (end < _finish)
			{
				*end = *(end + 1);
				end++;
			}
			_finish--;
			return pos;
		}
		iterator erase(iterator first,iterator last)
		{
			assert(first >= _start && first <= _finish);
			assert(last >= _start && last <= _finish);
			assert(first <= _finish);
			iterator it1 = first, it2 = last;
			size_t len = last - first;
			//1 2 3 4 5
			while (it1 <= last)
			{
				*it1 = *(it2);
				it1++;
				it2++;
			}
			_finish-=len;
			return last;
		}
		void push_back(const T& x)
		{
 			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}
			*_finish = x;
			_finish++;
		}
		//匿名对象当省略值 如果是内置类型 c++会特殊处理 升级成对象 调用无参构造
		void resize(size_t n, const T& val = T())
		{
			if (n < capacity())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
		}
		void pop_back()
		{
			erase(--end());
		}
		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start && pos <= _finish); //等于就是尾插和头插
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
				//解决内部迭代器失效
				pos = _start + len;
			}
			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				end--;
			}
			*pos = x;
			_finish++;
			return pos;
		}
		size_t size() const
		{
			return _finish - _start;
		}
		size_t capacity() const
		{
			return _endofstorage - _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];
		}
	private:
		T* _start = nullptr;
		T* _finish =nullptr;
		T* _endofstorage = nullptr;
	};
}

总结

相比string的学习，你会发现vector的学习是很轻松的，就是一些基本的顺序表的函数实现，比较难的就是他的迭代器失效问题。会涉及到深浅拷贝以及如何处理的问题，这和他的设计理念是息息相关的。

kukubuzai
关注
【C++ 十二】C++ vector容器
qq_45138120的博客
04-05 4369
本文包含vector基本概念、vector构造函数、vector赋值操作、vector容量和大小、vector插入和删除、vector数据存取、vector互换容器、vector预留空间。
C++ vector详解
songbijian的博客
03-07 1250
本文主要分两大部分：第一部分为vector的底层实现原理以及相关机制，第二部分是vector内置常用操作。
C++ STL之vector容器
咸鱼势力登场
04-25 2879
vector容器的介绍 vector容器的使用 [1.vector的构造函数 2.vector的赋值操作 3.vector的容量与大小 4.vector的插入和删除 5.vector的数据存取 6.vector的互换容器 7.算法模块在vector的应用①find算法(std)②sort算法(std)]
C++容器篇，vector容器
CHAKMING1的博客
10-23 3618
C++的容器之一vector，介绍了其所有接口，包括增删改查和容量相关的成员哈桑农户，以及其底层实现。
【C++必备知识】vector容器
最新发布
qq_43387079的博客
03-10 919
vector容器的学习笔记
C++ vector容器
qq_43067406的博客
03-11 875
C++ vector容器
C++vector容器
Casper_AZ的博客
10-09 1548
vector
Vector c++的简单实现
12-01
简单的实现vector的功能，但有可能在扩容和缩容时降低效率
C++从文本文件读取数据到vector中的方法
09-01
在C++编程中，有时我们需要从文本文件读取数据并将其存储到容器中，例如`std::vector`。`std::vector`是一个动态大小的数组，它可以方便地扩展以适应不断变化的数据需求。本篇文章将详细讲解如何使用C++从文本文件...
C++——vector类
2301_80636070的博客
08-14 1429
(constructor)构造函数声明接口说明vector()（重点）无参构造构造并初始化n个val（重点）拷贝构造使用迭代器进行初始化构造。
C++——vector
Ll_R_lL的博客
09-29 7414
vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是。
C++——vector容器
weixin_47207479的博客
02-05 461
vector容器
C++容器使用详解---vector容器
weixin_73497355的博客
06-28 1740
本文主要介绍了vector容器的使用，以及在使用时的注意事项。
【C++】C++11之vector容器详解
qq_35902025的博客
10-15 2933
vector是STL(标准模板库)中的一个序列式容器，本质是一个类模板。vector和数组的区别是：vector是动态空间，随着元素的加入，它的内部机制会自行扩充空间容纳新元素。vector也可以解释为单端数组it实质上是一个迭代器指针,访问时需要解引用*it，解引用后的数据类型和相同。
c++之vector容器
weixin_44453694的博客
11-01 528
向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。
c++ vector容器详解，适合小白零基础
qq_73936405的博客
12-22 629
vector容器，也叫向量容器，功能与数组十分相似，可以理解成可变数组，在执行对数组的操作时效率较高。使用vector容器时要包含头文件#include<vector>
C++提高编程——vector容器
qq_2725的博客
11-05 1823
vector数据结构和数组非常相似，也称为单端数组。注意：insert和erase的参数都是迭代器。
C++中的容器——vector
Mrlossry的博客
09-17 1064
vector：vector的底层实际上就是一个数组（也称为顺序表），数据是连续存储在数组中的，因此vector是可以使用下标来进行访问的，但是它的大小并不是像数组一样是固定的，而是可以动态调整的。
vector c++
04-11
在C++中，vector是一个动态数组容器，它可以存储不同类型的元素，并且可以根据需要自动调整大小。vector提供了一系列的成员函数，可以方便地对元素进行插入、删除、访问和修改操作。 以下是vector的一些特点和常用操作： 1. 动态大小：vector可以根据需要自动调整大小，可以动态地添加或删除元素。 2. 随机访问：可以通过下标来访问vector中的元素，支持常数时间的随机访问。 3. 连续存储：vector中的元素在内存中是连续存储的，这样可以提高访问效率。 4. 插入和删除：可以在任意位置插入或删除元素，插入和删除操作可能导致内部元素的重新分配和复制。 5. 大小和容量：vector有两个重要的成员函数size()和capacity()，前者返回当前元素个数，后者返回当前容量（即可容纳的最大元素个数）。 6. 自动扩容：当元素个数超过当前容量时，vector会自动分配更大的内存空间，并将原有元素复制到新的内存空间中。 使用vector时，需要包含头文件< vector >。下面是一些常用的vector操作示例： 1. 创建一个空的vector： vector<int> vec; 2. 在末尾添加元素： vec.push_back(10); 3. 访问元素： int value = vec; 4. 修改元素： vec = 20; 5. 删除末尾元素： vec.pop_back(); 6. 获取元素个数： int size = vec.size(); 7. 获取当前容量： int capacity = vec.capacity(); 8. 清空vector： vec.clear();
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值