【C++】STL中vector常见功能的模拟实现

最新推荐文章于 2024-07-24 08:30:00 发布
最新推荐文章于 2024-07-24 08:30:00 发布
阅读量897 收藏 32
点赞数 42
分类专栏： 高质量Ｃ++的学习 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64826370/article/details/139391715
版权

前言：在上一篇中我们讲到了Vector的一些常见功能的使用方式，今天为了进一步的去学习Vector和能够更深度的去理解Vector的一些底层的原理。

💖 博主CSDN主页:卫卫卫的个人主页 💞
👉 专栏分类:高质量Ｃ++学习 👈
💯代码仓库:卫卫周大胖的学习日记💫
💪关注博主和博主一起学习!一起努力！
在这里插入图片描述

目录标题

Vector的大体框架

在vector中本质是由三个指针变量组成的，且vector中可以存储各种类型的对象，因此我们使用模板在这里插入图片描述

namespace bit
{
	template<class T>//因为在使用的时候Vector中可以是任意类型所以我们调用模板
	class vector
	{
	public:
		typedef T* iterator;//迭代器
		typedef const T* const_iterator;
	private:
		iterator _start = nullptr; //容器的起始位置  // T* _start
		iterator _finish = nullptr;//容器中所使用的元素的最后一个位置
		iterator _endofstorage = nullptr;//容器中所有元素的最后一个位置
	};
}

Vector中的构造函数

无参构造

我们也可以直接在成员变量中对其直接给初始值，不写这个无参构造函数也是可以的。

vector()
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
}

拷贝构造(传统写法)

在拷贝构造中有两种写法，一个传统写法一个现代写法，由于传统写法要调用的函数我们得到后面才会去实现，所以现代写法作者就先放在后面了，这里先写的传统写法.

  1. 如果我们不自己实现，让编译器去实现，就是浅拷贝，会出现问题，故需我们自己实现深拷贝，v2(v1),即只要让v2拷贝一份新的数据即可（使v2和v1不是指向同一份数据）。
  2. 因此我们需要先开辟一块和需要拷贝的对象的同样大的空间，让新的对象指向这一块空间，在把值依次拷贝过去。(代码如下)
vector(const vector<T>& V) 
{
	//传统写法
	_start = new T[V.capacity()];
	_finish = _start;//让_finish指向现在的位置，然后依次进行赋值
	_endofstorage = _start + V.capacity();
	for (size_t i = 0; i < V.size(); i++)
	{
		*_finish = V[i];
		_finish++;
	}
	//此时finish指向的就是最后一个有效的元素的后一个位置
}

析构函数

关于析构函数这里就不过多的介绍了，就是把容器给销毁，然后置空即可。

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

swap函数

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

赋值重载operator=

代码思路:

  1. 传过来的对象会产生一个临时变量，临时变量会有一块独立的空间，这块空间和原本需要的值进行交换即达到了深拷贝的效果，然后返回*this即可达到连续赋值的效果。
vector<T>& operator=(vector<T> v)//现代写法
{
	swap(v);
	return *this;
}

Vector容器中的遍历方式

operator[]遍历容器

1.我们通过运算符重载可以写出两个operator的容器的遍历方式，一种是可以对其进行修改和操作，一种是只可以对其进行操作不可以修改

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

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

迭代器的遍历和范围for

当然了，迭代器也有可读和可写的两个版本(如下所示),且我们在前面的学习中知道，范围for的本质也就是迭代器进行遍历，只要有迭代器我们就能实现范围for了。

iterator begin()//返回起始位置
{
	return _start;
}

iterator end()//结束位置
{
	return _finish;
}

const_iterator begin() const
{
	return _start;
}

const_iterator end()const
{
	return _finish;
}
void test2()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(1);
	v1.push_back(1);
	v1.push_back(1);
	
	cout << "迭代器遍历" << endl;
	vector<int>::iterator it = v1.begin();
	while (it != v1.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	cout << "范围for遍历" << endl;
	for (auto e : v1)
		cout << e << " ";
	cout << endl;
}

在这里插入图片描述

打印函数print_vector(const vector& v)

void print_vector(const vector<T>& v)
{
	for (size_t i = 0; i < v.size(); i++)
	{
		cout << v[i] << " ";
	}
	cout << endl;
}

Vector容器中相关的增删查改的函数

查看容器中有效元素的个数- size()

代码思路：_finsh指向最后一个元素的后一个元素，_start指向第一个元素，两个指针相减就是元素的个数。

size_t size()const //元素个数
{
	return _finish - _start;
}

查看容器中国的容量的大小- capacity()

这里和上面的size()函数同理就不过多的解释了。

size_t capacity()const //总的容量
{
	return _endofstorage - _start;
}

调整和检查容量的大小- reserve(size_t n)

代码思路：

  1. 我们首先需要看传过来的大小是否比原本的容量还大，如果比原本的容量还大我们就需要对其进行扩容，比他小我们就不需要处理，因为通常都不会进行缩容的操作。
  2. 在前面string类的模拟实现的时候我们知道在C++中是没有realloc这样的函数的，因此我们只能开辟一块新的空间，然后将原本的值拷贝过去，在将旧空间的指针指向新空间，在释放掉旧的空间。
  3. 这里我们需要注意的是，我们需要将原本旧的空间的size记录下来，因为在前面的size函数中是元素的个数是_finish - _start，此时_start指向了一块新的空间，如果直接对他们相减就会导致越界等问题的发生(如下图所示)。
    在这里插入图片描述
void reserve(size_t n)//调整和检查容量
{
	if (capacity() < n)
	{
		T* tmp = new T[n];
		size_t old_size = size();//因原本的_start在后面会改变，放在野指针的出现我们需要对old_size进行存储
		for (size_t i = 0; i < old_size; i++)
		{
			tmp[i] = _start[i];
		}
		delete[] _start;
		_start = tmp;
		_finish = tmp + old_size;//用之前记录的size来更新_finsh
		_endofstorage = tmp + n;
	}
}

调整向量的大小-resize(size_t n, const T& value = T())

代码思路:
1.这里同理，我们需要看传过来的容量是否比原本的大，大的话我们就进行扩容的操作，如果使用者指定了value的值，就将扩容的空间的值全部指定成使用者指定的值，没有指定就使用默认值，小的话对原本的_finish进行更新即可。
2. 这里很多人不懂的是为什么使用匿名对象T(),在前面我们说过自定义类型会调用它的默认构造函数去初始化他的匿名对象，但是T是内置类型的话也会有自己的默认构造函数，如下图所示。
在这里插入图片描述

void resize(size_t n, const T& value = T())//使用半缺省，扩容的话就把剩余的部分全部扩容成value
{
	if (n > size())
	{
		reserve(n);
		while (_finish < _start + n)
		{
			*_finish = value;
			_finish++;
		}
	}
	else
	{
		_finish = _start + n;
	}
}

尾插数据- push_back(const T& val)

代码思路:

  1. 同理们在插入数据的时候需要查看空间的大小是否足够，如果不够扩容即可。
  2. 直接在原本的_finish进行赋值，再让其往后更新一位即可。
void push_back(const T& val)
{
	//insert(end(), val);
	if (_endofstorage == _finish)//判断容量是否是满的
	{
		reserve(capacity() == 0 ? 4 : capacity() * 2);
	}
	*_finish = val;
	_finish++;

}

尾删数据-pop_back()

代码思路：

  1. 我们需要判断是否还有数据，如果没有数据就不能进行删除
  2. 我们直接和之前顺序表一样的玩法，让其尾部往前移动一位即可。
void pop_back()
{
	assert(_finish > _start);
	--_finish;
}

插入数据-insert(iterator pos,const T& val)

代码思路:

  1. 同理我们需要判断是否需要扩容，如果需要扩容的话我们需要注意的是在调用reserve函数时候会对底层的_start和_finish进行修改，所以我们需要对原本的长度进行记录，否则就无法知道原本的长度了。
  2. 此时我们要插入的位置，就是新的_start+len此时的位置了。
  3. 这里我们找到尾部的位置让pos后的位置依次往后移动一位即可，然后再将需要插入的值赋值给pos的位置即可完成插入。
void insert(iterator pos,const T& val)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	if (_finish == _endofstorage)//判断是否需要扩容
	{
		size_t len = pos - _start;//同理需要记录原本的长度，因为在reserver后会对原本的_start进行修改
		reserve(capacity() == 0 ? 4 : capacity() * 2);//扩容了的话原本的_start
		//如果扩容了就要更新pos
		pos = len + _start;
	}
	iterator it = _finish - 1;
	while (it >= pos)
	{
		*(it + 1) = *it;
		--it;
	}
	*pos = val;
	++_finish;
}

讲到这里很多朋友就会发现，那么我们的push_back函数也可以直接调用insert函数即可，两个写成一个就行，代码如下:

void push_back(const T& val)
{
	insert(end(), val);//直接尾插即可
}

删除数据- erase(iterator pos)

代码思路:

  1. 我们这里需要判断删除的数据是否在容器有效数据的区间内
  2. 同理我们只需要将删除数据位置的区间全部往前移动一个覆盖掉删除的数据即可，然后更新_finish即可完成删除。
iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos <= _finish);
	iterator it = pos + 1;
	while (it < _finish)
	{
		*(it - 1) = *it;
		++it;
	}

	--_finish;
	return pos;//返回被删除数据的下一个位置,那就是还是原位置，原位置的数据已经被删除了
}

查看容器中的数据是否为空Empty()

bool Empty()
{
	return _start == _finish;
}

vector中构造函数的一点延伸

拷贝构造的现代写法

代码思路：

  1. 我们直接用reserve开辟一个一样大的空间，相当于开辟了一块新的空间，达到了深拷贝的效果，然后在对其每个数据进行尾插即可。
vector(const vector<T>& V) 
{
	reserve(V.capacity());//直接开辟一个一样大的空间，然后每个数据进行尾插
	for (auto& e : V)
	{
		push_back(e);
	}
}

区间构造函数

代码思路：
1.这里直接将该区间的数据依次插入到*this中的容器中即可

template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
	while (first != last)
	{
		push_back(*first);
		++first;
	}
}

列表初始化构造(c++11以上的写法）

代码思路:

  1. initializer_list是C++11引入的一种数据结构，用于表示一个初始化列表（initializer list）。它是一个模板类，定义在<initializer_list>头文件中。initializer_list可以用于在函数参数中传递一组值，也可以用于对象的初始化。它的语法类似于数组，使用花括号{}括起一组值，并以逗号分隔(这里就不过多的讲解了，后面会单独写一篇博客进行讲解)。
  2. 剩下的同理检查内存容量，然后对这里直接对其每个数据进行尾插就行。
vector(initializer_list<T> il)
{
	reserve(il.size());
	for (auto& e : il)
	{
		push_back(e);
	}
}

总体代码

using namespace std;
#include <iostream>
#include <assert.h>
namespace bit
{
	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;
		}

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

		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
		}

		//V2(v1) v2是对v1的值拷贝，叫浅拷贝，v1生命周期结束，析构v1，v2生命周期结束释放V2，，
		vector(const vector<T>& V) 
		{
			reserve(V.capacity());
			for (auto& e : V)
			{
				push_back(e);
			}

			//传统写法
			//_start = new T[V.capacity()];
			//_finish = _start;//让_finish指向现在的位置，然后依次进行赋值
			//_endofstorage = _start + V.capacity();
			//for (size_t i = 0; i < V.size(); i++)
			//{
			//	*_finish = V[i];
			//	_finish++;
			//}
		}

		vector(initializer_list<T> il)
		{
			reserve(il.size());
			for (auto& e : il)
			{
				push_back(e);
			}
		}

		// 类模板的成员函数可以是函数模板
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

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

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

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

		void reserve(size_t n)//调整和检查容量
		{
			if (capacity() < n)
			{
				T* tmp = new T[n];
				size_t old_size = size();//因原本的_start在后面会改变，放在野指针的出现我们需要对old_size进行村粗
				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;
				_start = tmp;
				_finish = tmp + old_size;
				_endofstorage = tmp + n;
			}
		}

		void resize(size_t n, const T& value = T())//使用半缺省，扩容的话就把剩余的部分全部扩容成value
		{
			if (n > size())
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = value;
					_finish++;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

		void insert(iterator pos,const T& val)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			if (_finish == _endofstorage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);//扩容了的话原本的_start
				//如果扩容了就要更新pos
				pos = len + _start;
			}
			iterator it = _finish - 1;
			while (it >= pos)
			{
				*(it + 1) = *it;
				--it;
			}
			*pos = val;
			++_finish;
		}

		void push_back(const T& val)
		{
			//insert(end(), val);
			if (_endofstorage == _finish)//判断容量是否是满的
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			*_finish = val;
			_finish++;
		}

		void pop_back()
		{
			assert(_finish > _start);
			--_finish;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			iterator it = pos + 1;
			while (it < _finish)
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;
			return pos;//返回被删除数据的下一个位置,那就是还是原位置，原位置的数据已经被删除了
		}

		bool Empty()
		{
			return _start == _finish;
		}

	private:
		iterator _start = nullptr; //容器的起始位置  // T* _start
		iterator _finish = nullptr;//容器中所使用的元素的最后一个位置
		iterator _endofstorage = nullptr;//容器中所有元素的最后一个位置
	};

	template<class T>
	void print_vector(const vector<T>& v)
	{
		for (size_t i = 0; i < v.size(); i++)
		{
			cout << v[i] << " ";
		}
		cout << endl;
	}

	void test1()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(1);
		v1.push_back(1);
		v1.push_back(1);
		//print_vector(v1);
		//vector<int> v2 = { 1,2,3,4,5 };
		//print_vector(v2);
		vector <int>v3(v1);
		print_vector(v3);
		for (auto e : v1)
		{
			cout << e << " ";
		}
	}
	void test2()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(1);
		v1.push_back(1);
		v1.push_back(1);
		
		cout << "迭代器遍历" << endl;
		vector<int>::iterator it = v1.begin();
		while (it != v1.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
		cout << "范围for遍历" << endl;
		for (auto e : v1)
			cout << e << " ";
		cout << endl;
	}
	
	void test3()
	{
		vector<int> v1 = { 1,3,4,6 };
		v1.insert(v1.begin()+2, 10);
		print_vector(v1);
	}
}

好啦，今天的内容就到这里啦，下期内容预告stl中list的使用，博主前段时间有点事情，后面这段时间会加班加点的更新！

结语：今天的内容就到这里吧，谢谢各位的观看，如果有讲的不好的地方也请各位多多指出，作者每一条评论都会读的，谢谢各位。

🌏🗺️ 这里祝各位接下来的每一天好运连连 💞💞
卫卫周大胖;
关注
  • 42
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 30
    评论
专栏目录
C++ STL中 vector 的模拟实现
Butayarou的博客
03-20 1388
文章目录一、前言二、模拟实现的意义何在？三、vector类的模拟实现成员函数：0.迭代器相关函数begin 函数end 函数1.构造函数2.析构函数3.拷贝构造函数4.赋值重载函数5. size 函数6. capacity 函数7. swap 函数 一、前言 在C++的STL中，vector 是一个顺序容器，代表一个可动态增长的数组。因此，自己在进行模拟实现时，跟写动态顺序表类似。 vector 是一个类模板。 推荐的 C/C++ 参考文档：http://www.cplusplus.com 二、模拟实现
C++ STL --- vector类模拟实现
weixin_57761086的博客
08-29 1227
C++STL之vector的模拟实现，模拟实现了构造模块、迭代器模块、容量模块、元素访问模块、修改模块。同时讲解了为什么不能用memset和memecpy函数。使用大量代码举例子。
C++ STL之vector的使用及模拟实现
czh1592272237的博客
01-21 921
本篇文章详细讲解了STL中vector的使用及模拟实现。
C++STL---vector模拟实现
weixin_73919606的博客
06-01 1076
vector模拟实现
【C++】STL之vector功能及模拟实现
m0_63198468的博客
07-24 725
本文讲解了vector接口的使用，并附有例子清晰易懂，重点讲解了vector的模拟实现，并且在模拟实现过程中，迭代器失效的问题和深浅拷贝的问题。
STL中vector类模拟实现
08-06
vector的模拟实现，非常适合初学者学习
c++ vector模拟实现代码
08-25
在C++标准模板库(STL)中，`vector`是一个非常关键的容器，它提供了类似于动态数组的功能。本文将深入探讨`vector`的实现原理，并通过一个简单的模拟代码来展示其核心机制。 首先，`vector`是一个序列容器，它允许在...
C++开源项目：模拟实现小型STL
11-27
本开源项目旨在模拟实现一个小型STL，帮助开发者更深入地理解STL的工作原理和设计思想。下面我们将详细探讨其中涉及的知识点。 1. **容器**：STL中的容器是用来存储数据的对象，如`vector`、`deque`、`list`、`set`...
C++的Vector实现.zip
08-20
本项目的目标是实现一个自定义的`Myvector`类，模拟`std::vector`的部分功能。 `std::vector`的核心特性包括： 1. 动态增长：当向vector中添加元素，且当前容量不足时，vector会自动分配更大的内存空间并复制现有...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1133
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1130
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 325
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 260
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
热门推荐
面试高手的博客
07-21 4万+
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
C++中的模板函数和模板类
2302_81171591的博客
07-22 659
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
最新发布
siu~
07-24 748
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 2185
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
C++初学（1）
2301_79654372的博客
07-23 1150
c++c初学
模拟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是支持多线程的。
评论 30
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

卫卫周大胖;

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值