C++ STL --- vector类模拟实现

已于 2022-08-30 22:37:59 修改
阅读量1.1k 收藏 23
点赞数 20
分类专栏： C++ 文章标签： c++ STL vector 容器 vector模拟实现
于 2022-08-29 20:34:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57761086/article/details/126577389
版权

目录

1.构造模块

  (1)无参构造

  (2)半缺省构造

  (3)区间构造的必备知识

  (4)区间构造

  (5)拷贝构造

  (6)赋值运算符重载

  (7)析构函数

2.迭代器模块

  (1)正向迭代器

  (2)反向迭代器

3.容量模块

  (1)获取有效元素个数

  (2)获取容量大小

  (3)判空函数

  (4)扩容函数

  (5)设置有效元素个数

4.元素访问模块

  (1)获取首元素

  (2)获取尾元素

  (3)重载[]

5.修改模块

  (1)尾插

  (2)尾删

  (3)任意位置插入   

  (4)指定位置删除

  (5)清空有效元素

6.总体代码

        vector是这是C++中的典型容器，它是动态类型的顺序表，任何类型的元素都可以存放。接下来将在以下几个方面进行模拟实现：构造模块、迭代器模块、容量模块、元素访问模块、修改模块。

        因为类中的函数非常多，所以只着重实现一些常用的函数。(本文代码均在win10系统下的vs2019中验证)

1.构造模块

        在构造模块，先来思考一下该设置些什么成员变量？首先要有一个 _start 指针指向一块空间，其次一个 _finish 指针指向这块空间中最有一个有效元素的下一个位置，_end指针指向空间的最后一个位置的下一个位置。而空间中的有效元素个数和容量可以通过指针相减得到。

        用下面这幅图理解一下三个指针的位置：总空间有8个位置，前五个位置有元素，_finish指向第六个位置，_end需要指向第八个位置后面的空间。当有效元素把位置占满的时候，_finish和_end自然就指向同一块空间。

  (1)无参构造

        由于vector类是可以存放任意类型的元素的，要模拟实现它自然也要做到存放任意类型。那么就需要用到模板了。T是存放的元素类型，T*是指向T类型元素的指针。

        代码一：注意创建对象时必须声明存储什么类型的对象。语法：Vector<T> v

        既然是空参构造，那么说明现在并不给对象中存放元素，那直接把三个指针都置空就好。

//代码一
#include "iostream"
using namespace std;

//Vector类存储的数据是任意类型，所以需要设置模板参数
template<typename T> 
class Vector {
public:
	T* _start;//指向T类型元素的首元素的指针
	T* _finish;//指向最后一个有效元素下一个位置
	T* _end;//指向顺序表空间最后一个位置的下一个位置。
public:
	Vector() 
		:_start(nullptr)
		,_finish(nullptr)
		,_end(nullptr)
	{}
};

int main() {
	Vector<int>v;
}

  (2)半缺省构造

        代码二：这里n的类型一定要给成int，不可以给成size_t。不然运行时会遇到错误，在区间构造时就知道了。

//代码二
Vector(int n, const T& val = T())
	:_start(new T[n])//在初始化时直接从堆上申请空间
{
	for (int i = 0; i < n; i++) {
		_start[i] = val;
	}
	//_finish指向最后一个有效元素的下一个位置
	_finish = _start + n;
	//_end指向顺序表最后一个位置的下一个位置
	_end = _finish;
}

  (3)区间构造的必备知识

        vector类的区间构造很强大，不仅是在使用方法中介绍的利用数组来进行区间构造，也可以用链表来进行区间构造，所以实现时要格外注意不可以直接拷贝，需要将区间内元素遍历一遍才可以。

        在区间构造时候因为可以用链表来构造，所以传入的迭代器自然也是链表的迭代器，这样一来，T类型的迭代器就不能满足条件了，所以我们也要为迭代器设置模板参数，让任意类型的迭代器都可以进行区间构造。

  (4)区间构造

        代码三：这里搭配测试用例解释一下第二个循环。

        看一下区间构造，还记得上面为什么需要把参数类型给成int吗？如果你想构造对象时初始化10个5，是不是这样写 Vector<int>v(10,5)。

        模板不会进行类型转换，根据你的参数推演，如果能找到匹配的就使用。检测到size_t发现不匹配就继续找，找到区间构造后发现可以使用，因为它可以把 Iterator 当成int类型。

        可是原本的迭代器是需要解引用的，现在对整形数字解引用，可不就出错了么？

//代码三
template<typename Iterator>
Vector(Iterator first, Iterator last) {
	Iterator it = first;
	size_t num = 0;//统计元素个数
	while (it != last) {
		num++;
		it++;
	}

	_start = new T[num];
	_finish = _start;
	while (first != last) {
		*_finish = *first;
		_finish++;
		first++;
	}
	_end = _finish;
}

int main() {
	int arr[] = { 1,2,3,4,5,6 };
	Vector<int>v(arr,arr+sizeof(arr)/sizeof(arr[0]));
}

        搭配图片理解一下第二个循环：

        arr指向的是首元素，sizeof(arr)/sizeof(arr[0]) 是求数组元素个数，共6个。arr+6就指向了数组外的空间。当first移动到last位置说明元素遍历完毕，此时对应的_finish也指向了最后一个有效元素的后一个位置。(同时这也是顺序表的最后一个位置的后一个位置了，因为申请时只申请了这么多空间)

        重点来了：注意first迭代器也是可以++的，这是因为对应的类中现在基本都会重载++，这样链表也就不需要用指针指向next这样的操作来访问了，会方便很多，也更直观。

  (5)拷贝构造

        代码四：

//代码四
Vector(const Vector<T>& v)
	:_start(new T[v.Size()]) //这里用到的Size函数后面会实现的
{
	size_t num = v.Size();
	for (size_t i = 0; i < num; i++) {
		_start[i] = v._start[i];
	}
	//让对应的指针指向应该指向的位置
	_finish = _start + num;
	_end = _finish;
}

  (6)赋值运算符重载

        代码五：因为这里传递的是值，会发生值拷贝，产生临时对象，那么我们把两个对象的指针指向的空间交换即可。一定要返回，因为要实现连续赋值。

//代码五：
Vector& operator=(const Vector v) {
	std::swap(_start, v._start);
	std::swap(_finish, v._finish);
	std::swap(_end, v._end);
	return *this;
}

  (7)析构函数

        代码六：这里检查指针是否为空，虽然经过测试指针指向空值时，delete[] 指针不会报错，但出于谨慎，还是加上检查比较好。

//代码六
~Vector() {
	if (_start) {
		delete[] _start;
	}
	_start = _finish = _end = nullptr;
}

2.迭代器模块

        迭代器模块的模板参数要单独给出，不可以使用区间构造那块的，因为迭代器不涉及多种元素，它只返回本类的元素迭代器，只有一种。

  (1)正向迭代器

        代码七：

//代码七
typedef T* iterators;

iterators Begin() {
	return _start;
}

iterators End() {
	return _finish;
}

  (2)反向迭代器

        代码八：反向迭代器可以直接复用正向迭代器。

//代码八
typedef T* iterators;

iterators Rbegin() {
	return End();
}

iterators Rend() {
	return Begin();
}

3.容量模块

  (1)获取有效元素个数

        这里就可以体会到指针的便捷了，直接相减就得到了元素个数。

        代码九：

//代码九
size_t Size() const{
	return _finish - _start;
}

  (2)获取容量大小

        代码十：道理同上。

//代码十
size_t Capacity()const {
	return _end - _start;
}

  (3)判空函数

      代码十一：  这两个指针相同说明并没有元素的存在。

//代码十一
bool Empty()const {
	return _start == _finish;
}

  (4)扩容函数

           代码十二：只考虑扩大，不考虑缩小。

//代码十三
void Reserve(size_t newCapacity) {
	size_t oldCapacity = Capacity();
	size_t oldSize = Size();

	T* temp = new T[newCapacity];
	//当要设置的新空间大于旧空间
	if (newCapacity > oldCapacity) {
		//判断首指针是否是空
		if (_start) {
			//进行深拷贝
			//思考：memcpy可以使用吗？
			for (size_t i = 0; i < oldSize; i++) {
				temp[i] = _start[i];
			}
			//释放旧空间
			delete[] _start;
		}
		_start = temp;
		_finish = _start + oldSize;
		_end = _start + newCapacity;
	}	
}

    在扩容函数中思考一个问题，为什么没有使用memcpy函数？原因是memcpy是按字节拷贝，会有程序崩溃的风险。使用下面的例子来验证。

        代码十三：举例，假设使用扩容函数中使用memcpy函数，并且vector中存储S类型的对象。这里因为是举例子，所以代码给的很粗糙，理解一下意思就好。

        首先使用s1和s2构造v对象，然后进行尾插，这样会导致扩容。

//代码十三
class S {
public:
	char* str;
};

int main(){
    S s1;
    S s2;
    vector<S> v{s1,s2};
    
    S s3;
    v.push_back(s3);
}

        下面这幅图就是验证图。

        S对象内存储的是指针，构造Vector时里面有两个S类型的元素，两个s元素中分别有一个指针指向一个有"\0"元素的空间。然后尾插一个元素，导致扩容。

        扩容后使用memcpy按字节将vector中的元素拷贝到新空间中。一切看起来都那么完美。可是旧的vector对象中地址指针(蓝色的地址线)需要释放，释放后新空间中的指针(红色地址线)却依然指向被释放的空间。这不就是野指针吗？这样一来，一旦试图访问这块空间，必然程序崩溃。

  (5)设置有效元素个数

        这里要告诉大家，不要使用memset函数。因为memset函数也是按字节将元素直接放到指定空间中。C 库函数 void *memset(void *str, int c, size_t n) 复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。

        字符的字节是1字节，如果你要用它放n个T类型数据到指向的空间，它是怎么做的？它会把T类型的数据往空间中的前n个字节，每个字节都放一个！

        代码十四：

//代码十四：
void Resize(size_t newSize, const T& val = T()) {
	size_t oldCapacity = Capacity();
	size_t oldSize = Size();
	//要设置的有效元素个数大于现在的有效元素
	if (newSize > oldSize) {
		//要设置的有效元素个数大于现有空间，扩容
		if (newSize > oldCapacity) {
			Reserve(newSize);
		}
		//思考：memeset可以用吗？
		for (size_t i = oldSize; i < newSize; i++) {
			_start[i] = val;
		}
	}
	_finish = _start + newSize;
}

4.元素访问模块

  (1)获取首元素

        代码十五：这里给出两种类型，以便于const对象使用。

//代码十五
T& Front() {
	return _start[0];
}
const T& Front()const {
	return _start[0];
}

  (2)获取尾元素

        代码十六：两种类型，道理同上。

//代码十六
T& Back() {
	return *(_finish - 1);
}
const T& Back()const {
	return *(_finish - 1);
}

  (3)重载[]

        代码十七：也是两种类型。注意assert函数使用时需要包含头文件。

//代码十七
#include <assert.h>
T& operator[](size_t index) {
	//需要判断是否越界
	assert(-1<index < Size());
	return _start[index];
}
const T& operator[](size_t index)const {
	assert(-1<index < Size());
	return _start[index];
}

5.修改模块

  (1)尾插

        代码十八：尾插可能需要扩容，一旦扩容，就给的空间大一点，尽量减少扩容次数。

//代码十八
void Push_back(const T& val) {
	//判断顺序表是否已经存满了
	if (_finish == _end) {
		Reserve(Capacity() * 2);
	}
	*_finish = val;
	_finish++;
}

  (2)尾删

        代码十九：

//代码十九
void Pop_back() {
	if (Empty()) {
		return;
	}
	_finish--;
}

  (3)任意位置插入   

        代码二十：  需要考虑越界问题

//代码二十
iterators Insert(iterators index, const T& val) {
	//判断迭代器是否越界
	if (index < _start || index > _finish)
		return End();
	//判断空间是否存满
	if (_start == _finish)
		Reserve(Capacity() * 2);

	auto it = _finish;
	while (it != index) {
		*it = *(it - 1);
		it--;
	}
	*index = val;
	_finish++;
	return index;
}

  (4)指定位置删除

        代码二十一：需要考虑越界问题

//代码二十一
iterators Erase(iterators index) {
	//判断迭代器是否越界
	if (index < _start || index > _finish)
		return End();
	auto it = index;
	//将index后的元素往前搬移一位
	while (it != _finish) {
		*it = *(it + 1);
		it++;
	}
	_finish--;
	return index;
}

  (5)清空有效元素

        代码二十二：

//代码二十二
void Clear() {
	_finish = _start;
}

6.总体代码

        将代码进行调整后改成整体代码如下：

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

//Vector类存储的数据是任意类型，所以需要设置模板参数
template<typename T> 
class Vector {
private:
	T* _start;//指向T类型元素的首元素的指针
	T* _finish;//指向最后一个有效元素下一个位置
	T* _end;//指向有效空间的下一个位置。
public:
//构造模块
//
	//无参构造
	Vector() 
		:_start(nullptr)
		,_finish(nullptr)
		,_end(nullptr)
	{}
	//半缺省构造
	Vector(int n, const T& val = T())
		:_start(new T[n])//在初始化时直接从堆上申请空间
	{
		for (int i = 0; i < n; i++) {
			_start[i] = val;
		}
		//_finish指向最后一个有效元素的下一个位置
		_finish = _start + n;
		//_end指向顺序表最后一个位置的下一个位置
		_end = _finish;
	}
	//区间构造
	template<typename Iterator>
	Vector(Iterator first, Iterator last) {
		Iterator it = first;
		size_t num = 0;//统计元素个数
		while (it != last) {
			num++;
			it++;
		}

		_start = new T[num];
		_finish = _start;
		while (first != last) {
			*_finish = *first;
			_finish++;
			first++;
		}
		_end = _finish;
	}
	//拷贝构造函数
	Vector(const Vector<T>& v)
		:_start(new T[v.Size()]) //这里用到的Size函数后面会实现的
	{
		size_t num = v.Size();
		for (size_t i = 0; i < num; i++) {
			_start[i] = v._start[i];
		}
		//让对应的指针指向应该指向的位置
		_finish = _start + num;
		_end = _finish;
	}
	//赋值运算符重载
	Vector& operator=(const Vector v) {
		std::swap(_start, v._start);
		std::swap(_finish, v._finish);
		std::swap(_end, v._end);
		return *this;
	}
	//析构函数
	~Vector() {
		if (_start) {
			delete[] _start;
		}
		_start = _finish = _end = nullptr;
	}
//迭代器模块
//
	typedef T* iterators;
	//正向迭代器 
	iterators Begin() {
		return _start;
	}
	iterators End() {
		return _finish;
	}
	
	//反向迭代器
	iterators Rbegin() {
		return End();
	}
	iterators Rend() {
		return Begin();
	}
//容量模块
//
	//有效元素个数
	size_t Size() const{
		return _finish - _start;
	}
	//容量大小
	size_t Capacity()const {
		return _end - _start;
	}
	//判空函数
	bool Empty()const {
		return _start == _finish;
	}
	//扩容函数
	void Reserve(size_t newCapacity) {
		size_t oldCapacity = Capacity();
		size_t oldSize = Size();

		T* temp = new T[newCapacity];
		//当要设置的新空间大于旧空间
		if (newCapacity > oldCapacity) {
			//判断首指针是否是空
			if (_start) {
				//进行深拷贝
				//思考：memcpy可以使用吗？
				for (size_t i = 0; i < oldSize; i++) {
					temp[i] = _start[i];
				}
				//释放旧空间
				delete[] _start;
			}
			_start = temp;
			_finish = _start + oldSize;
			_end = _start + newCapacity;
		}	
	}
	//设置有效元素函数
	void Resize(size_t newSize, const T& val = T()) {
		size_t oldCapacity = Capacity();
		size_t oldSize = Size();
		//要设置的有效元素个数大于现在的有效元素
		if (newSize > oldSize) {
			//要设置的有效元素个数大于现有空间，扩容
			if (newSize > oldCapacity) {
				Reserve(newSize);
			}
			//思考：memeset可以用吗？
			for (size_t i = oldSize; i < newSize; i++) {
				_start[i] = val;
			}
		}
		_finish = _start + newSize;
	}
//元素访问模块
//
	//获取首元素
	T& Front() {
		return _start[0];
	}
	const T& Front()const {
		return _start[0];
	}
	//获取尾部元素
	T& Back() {
		return *(_finish - 1);
	}
	const T& Back()const {
		return *(_finish - 1);
	}
	//重载[]
	T& operator[](size_t index) {
		//需要判断是否越界
		assert(-1<index < Size());
		return _start[index];
	}
	const T& operator[](size_t index)const {
		assert(-1<index < Size());
		return _start[index];
	}
//修改模块
//
	//尾插
	void Push_back(const T& val) {
		//判断顺序表是否已经存满了
		if (_finish == _end) {
			Reserve(Capacity() * 2);
		}
		*_finish = val;
		_finish++;
	}
	//尾删
	void Pop_back() {
		if (Empty()) {
			return;
		}
		_finish--;
	}
	//任意位置的插入
	iterators Insert(iterators index, const T& val) {
		//判断迭代器是否越界
		if (index < _start || index > _finish)
			return End();
		//判断空间是否存满
		if (_start == _finish)
			Reserve(Capacity() * 2);

		auto it = _finish;
		while (it != index) {
			*it = *(it - 1);
			it--;
		}
		*index = val;
		_finish++;
		return index;
	}
	//任意位置删除
	iterators Erase(iterators index) {
		//判断迭代器是否越界
		if (index < _start || index > _finish)
			return End();
		auto it = index;
		//将index后的元素往前搬移一位
		while (it != _finish) {
			*it = *(it + 1);
			it++;
		}
		_finish--;
		return index;
	}
	//清空有效元素
	void Clear() {
		_finish = _start;
	}
};

int main() {
	Vector<int> v(10, 5);
	v.Push_back(9);
	v.Erase(v.End());
}

爱喝酸奶！
关注
  • 20
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
C++——STL之vector详解
weixin_59055853的博客
12-21 1359
学习了string之后，学习其他模板将会更容易上手，一起来看一下vector吧！vector是表示大小可以变化的数组的序列容器。
C++ 简析容器Vector
GuoBen_的博客
04-01 1356
向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。 一、基本概念向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能...
vector的实现及总结
qq_41078889的博客
08-17 3693
vector: vector的数据安排以及操作方式与array非常类似。两者唯一的差别就是在于空间的运用灵活性，array是静态空间，一旦分配了就是固定的，无法改变其大小。需要用户重新申请更大的空间，移动数据，释放原来的空间。而vector是动态空间，有其内部的空间分配机制来及时调整空间大小，其实就是vector把申请空间，移动数据，释放原来的空间等操作封装在内部，不需要用户去处理。 接下来我们自己实现一下vector，并给其加上空间配置器。 // 简单的vector容器实现，主要查看其嵌套类ite
【C++】STL — vector的使用 + 模拟实现
上上谦. 的博客
09-04 2425
本章我们将学习STL中另一个重要的类模板vector…vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。本质讲，vector使用动态分配数组来存储它的元素。vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。vector是向量的意思。能不能用vector来替代string呢？可以是可以，但是有区别的，string的部分功能vector实现不了。
【C++】STL——vector模拟实现
M的博客
06-20 1319
vector的模拟实现
C++模板三：STL向量容器vector简单实现、容器空间适配器allocator简单实现
Rain的博客
03-10 572
文章目录一、STL向量容器vector简单实现二、容器空间适配器allocator简单实现 一、STL向量容器vector简单实现 首先，我们了解一下什么是容器呢？ 容器：在C++中，容器被定义为：在数据存储上，有一种对象类型，它可以持有其他对象或指向其他对象的指针，这种对象类型就叫做容器。 简单理解，即容器就是保存其他对象的对象。而且，这种“对象”还有处理“其他对象”的方法。 我们平常喝水的的...
C++STL之vector的使用和实现
小赵小赵福星高照的博客
11-16 819
vector 文章目录vector什么是vector？vector的使用构造函数vector成员函数的使用vector的模拟实现迭代器和const迭代器的模拟实现无参构造函数的模拟实现size、capacity、empty成员函数的模拟实现operator[]模拟实现reserve模拟实现resize模拟实现push_back模拟实现pop_back模拟实现迭代器失效问题insert的模拟实现erase的模拟实现析构函数拷贝构造函数深拷贝传统写法深拷贝现代写法迭代器构造函数与swap函数模拟实现赋值重载赋值
【STL】模拟实现vector
weixin_60718941的博客
02-23 451
本文主要讲的是对vector的模拟实现。
【C++】模拟实现STL容器：vector
学了就忘是正常现象
11-24 1225
vector使用时需注意迭代器失效问题。解决方法：接收insert或erase返回值，更新当前迭代器 vector模拟实现需注意reserve中的深拷贝问题。
C++ STL之vector详解
热门推荐
行码棋
01-04 5万+
本文介绍了STL的vector的常用操作以及相关的注意事项
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
cpp-soa-iterator:使用 c++ struct-of-array 迭代器进行实验
06-06
C++ STL 中的vector容器和thrust device_vector容器可以很容易地用于实现结构数组数据模式。 例如，考虑一个二维点向量。 这可以用结构来实现： struct Point { double x; double y;}; 和 STL vector ： std::...
vector 模拟实现
03-20
对vector 的实现的模拟。使用《c++ primar》 中的部分代码，并进行了完善。
C++程序(类模板)
09-29
C++期末考试可能会考到的代码 类 类模板 模拟STL中的向量，支持用push.back()操作向Vector中加入对象，具有自动resize功能 迭代器
【C++系列】 STL中的vector用法详解及模拟实现
Li-eng的博客
11-27 988
STL——vector详解及模拟实现 一.vector的介绍及使用 vector的文档介绍 vector是表示可变大小数组的序列容器。 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素 进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自 动处理。 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小 为了增加存储空间。其做法是，分配一个新的数组，然后将全部
C++ STL之 vector（动态数组）详解
最新发布
zdlzf的博客
06-16 4359
vector为可变长数组（动态数组），定义的vector数组可以随时添加数值和删除元素。在局部函数中开vector数组，是在堆空间里面开的，与开全局变量比较类似，所以经常见到在局部函数中开大容量数组。1.头文件2.初始化一维初始化//定义了一个名为num的存int数据的一维数组//定义了一个名为num的存double数据的一维数组//node是结构体类型1.指定长度和初始值的初始化//定义一个长度为n的数组，动态定义，不指定初值默认初值为0//所有的元素均为0。
【c++】——STL容器之vector的使用和模拟实现
sjp11的博客
09-21 1450
vector的概述 vector本质是数据结构中的线性表，它是动态空间的数组，如果vector中的空间满了以后，它会先开辟一块更大的新空间，然后将旧空间的数据拷贝给新空间，再把旧空间的给释放掉。vector开辟的新空间的容量一般是旧空间的容量的两倍或者1.5倍，不同的编译器增容方式可能是不同的。例如再g++中vector是以两倍增长的，vs中vector是以1.5倍增长的。 vector常用接口 vector的接口有很多，在这里我就不一 一讲解，我只讲一些我们经常会用到的接口，如果遇到哪个接口不懂
C++：STL之Vector实现
myscratch的博客
11-29 1067
vector模拟实现、vector解析
模拟C++STL中的vector的实现
05-11
下面是一个简单的C++STL中vector的实现，仅供参考： ```c++ template<class T> class myVector{ private: T *data; // 存储空间指针 int capacity; // 当前容量 int size; // 元素个数 public: // 构造函数 myVector(){ data = new T[1]; // 初始容量为1 capacity = 1; size = 0; } // 析构函数 ~myVector(){ delete[] data; } // 返回元素个数 int getSize(){ return size; } // 返回容量 int getCapacity(){ return capacity; } // 添加元素 void push_back(T element){ if(size == capacity){ // 容量不足，扩容 T *newData = new T[capacity * 2]; for(int i=0; i<size; i++){ newData[i] = data[i]; } delete[] data; data = newData; capacity *= 2; } data[size++] = element; } // 删除最后一个元素 void pop_back(){ if(size > 0){ size--; } } // 访问元素 T& operator[](int index){ return data[index]; } }; ``` 这个实现中，我们使用了动态内存分配来实现vector的扩容和缩容，同时提供了getSize、getCapacity、push_back、pop_back、operator[]等常用操作。需要注意的是，这个实现并没有考虑线程安全等问题，实际上STL中的vector是支持多线程的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值