C++ | vector模拟实现

最新推荐文章于 2024-07-28 21:35:11 发布

安心学编程

最新推荐文章于 2024-07-28 21:35:11 发布

阅读量452

点赞数 2

分类专栏： C++知识点文章标签： c++ 算法前端 c语言

本文链接：https://blog.csdn.net/2301_78131481/article/details/137437119

版权

C++知识点专栏收录该内容

15 篇文章 0 订阅

订阅专栏

本文详细介绍了C++中的模板类vector的构造函数、拷贝构造、迭代器操作、动态内存管理方法（reserve和resize）、元素访问和修改（push_back,pop_back,insert,erase）以及析构函数。

摘要由CSDN通过智能技术生成

框架

#pragma once
#include <assert.h>
#include <iostream>
#include <string>
namespace bit
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		vector();
		vector(const vector<T>& v);
		template<class InputIterator>
		vector(InputIterator first, InputIterator end);
		void swap(vector<T>& v);
		vector<T>& operator=(vector<T> v);
		vector(size_t n, const T& val = T());
		vector(int n, const T& val = T());
		~vector();
		iterator begin();
		iterator end();
		const iterator begin() const;
		const iterator end() const;
		size_t size();
		size_t capacity();
		const size_t size() const;
        const size_t capacity() const;
		void reserve(size_t n);
		void resize(size_t n,const T& val=T());
		T& operator[](size_t pos);
		const T& operator[](size_t pos) const;
		void push_back(const T& val);
		void pop_back();
		void insert(iterator pos,const T& val);
		iterator erase(iterator pos);
		bool empty();

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _endofstorage = nullptr;
	};
	template<class T>
	void print_vector(const vector<T>& v);
}

构造函数

vector(){}

//vector的拷贝构造
vector(const vector<T>& v)
{
	reserve(v.capacity());
	for (auto& e : v)
	{
		push_back(e);
	}
}

//迭代器区间构造
//“一个类模板中可以嵌套函数模板”
template<class InputIterator>
vector(InputIterator first, InputIterator end)
{
	while (first != end)
	{
		push_back(*first);
		first++;
	}
}

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

//v3=v1——将v1赋值给v3
vector<T>& operator=(vector<T> v)
	//v1传值传参，v是v1的拷贝，不会修改v1本身
{
	swap(v);
	return *this;
}

//用n个val构造vector
vector(size_t n, const T& val = T())
{
	reserve(n);
	for (size_t i = 0; i < n; i++)
	{
		push_back(val);
	}
}

vector(int n, const T& val = T())
{
	reserve(n);
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}

析构函数

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

begin()&&end()

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

const iterator begin() const
{
	return _start;
}

const iterator end() const
{
	return _finish;
}

size()&&capacity()

size_t size()
{
	return _finish - _start;
}

size_t capacity()
{
	return _endofstorage - _start;
}

const size_t size() const
{
	return _finish - _start;
}

const size_t capacity() const
{
	return _endofstorage - _start;
}

reserve()&&resize()

//预留可以存储n个数据空间
//reserve如果比当前的capacity大，就扩容
//比他小就不扩容
void reserve(size_t n)
{
	size_t oldsize = size();
	if (n > capacity())
	{
		//先开辟空间new临时n
		T* tmp = new T[n];
		//复制数据
		//memcpy是浅拷贝
		//memcpy(tmp, _start, size() * sizeof(T));
		for (size_t i = 0; i < oldsize; i++)
		{
			tmp[i] = _start[i];
		}
		//释放旧的空间
		delete[] _start;

		//更新新的
		_start = tmp;
		_finish = tmp + oldsize;
		_endofstorage = tmp + n;

	}
}

void resize(size_t n,const T& val=T())
{
	if (n > size())
	{
		//插入val
		reserve(n);
		while (_finish < _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
	else
	{
		_finish = _start + n;
	}
}

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

push_back()

void push_back(const T& val)
{
	insert(end(), val);
	//if (_finish == _endofstorage)
	//{
	//	size_t old_size = size();
	//	size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
	//	//扩容
	//	reserve(newcapacity);
	//	//T* tmp = new T[newcapacity];
	//	//memcpy(tmp, _start, size() * sizeof(T));
	//	//delete[] _start;
	//	//_start = tmp;
	//	//_finish = tmp + old_size;//？
	//	_finish = tmp + size（）;//？
	//	【问题一：此时注意：size是通过start和finish计算的，此时start更新了，所以会导致出现问题】
	//	//_endofstorage = tmp + newcapacity;
	//}
	//*_finish = val;
	//++_finish;
}

pop_back()

//【pop_back】尾删
void pop_back()
{
	iterator pos = end() - 1;
	erase(pos);
	/*assert(!empty());
	--_finish;*/
}

insert()

void insert(iterator pos,const T& val)
	//注意这里与string中不同，string中pos用的是下标
	//但是vector用的是迭代器——指针（一个一个单位的内存编号是地址，不可能为0）
{
	//判断位置是否合法
	assert(pos>=_start);
	assert(pos <= _finish);
	//判断是否需要扩容
	if (size() == capacity())
	{
		size_t len = pos - _start;
		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		reserve(newcapacity);
		//【insert迭代器失效】——reserve之后pos的位置没有更新
		pos = _start + len;
	}
	iterator it = _finish - 1;
	while (it >= pos)
	{
		*(it + 1) = *it;
		--it;
	}
	*pos = val;
	_finish++;
}

erase()

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

empty()

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

完整代码

#pragma once
#include <assert.h>
#include <iostream>
#include <string>
namespace bit
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		vector()
		{

		}

		//vector的拷贝构造
		vector(const vector<T>& v)
		{
			reserve(v.capacity());
			for (auto& e : v)
			{
				push_back(e);
			}
		}

		//迭代器区间构造
		//“一个类模板中可以嵌套函数模板”
		template<class InputIterator>
		vector(InputIterator first, InputIterator end)
		{
			while (first != end)
			{
				push_back(*first);
				first++;
			}
		}

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

		}

		//v3=v1——将v1赋值给v3
		vector<T>& operator=(vector<T> v)
			//v1传值传参，v是v1的拷贝，不会修改v1本身
		{
			swap(v);
			return *this;
		}

		//用n个val构造vector
		vector(size_t n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		vector(int n, const T& val = T())
		{
			reserve(n);
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		//【析构函数】
		~vector()
		{
			delete[] _start;
			_start = _finish = _endofstorage = nullptr;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const iterator begin() const
		{
			return _start;
		}

		const iterator end() const
		{
			return _finish;
		}
		size_t size()
		{
			return _finish - _start;
		}

		size_t capacity()
		{
			return _endofstorage - _start;
		}

		const size_t size() const
		{
			return _finish - _start;
		}

		const size_t capacity() const
		{
			return _endofstorage - _start;
		}

		//预留可以存储n个数据空间
		//reserve如果比当前的capacity大，就扩容
		//比他小就不扩容
		void reserve(size_t n)
		{
			size_t oldsize = size();
			if (n > capacity())
			{
				//先开辟空间new临时n
				T* tmp = new T[n];
				//复制数据
				//memcpy是浅拷贝
				//memcpy(tmp, _start, size() * sizeof(T));
				for (size_t i = 0; i < oldsize; i++)
				{
					tmp[i] = _start[i];
				}
				//释放旧的空间
				delete[] _start;

				//更新新的
				_start = tmp;
				_finish = tmp + oldsize;
				_endofstorage = tmp + n;

			}
		}

		void resize(size_t n,const T& val=T())
		{
			if (n > size())
			{
				//插入val
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
			else
			{
				_finish = _start + n;
			}
		}

		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 push_back(const T& val)
		{
			insert(end(), val);
			//if (_finish == _endofstorage)
			//{
			//	size_t old_size = size();
			//	size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
			//	//扩容
			//	reserve(newcapacity);
			//	//T* tmp = new T[newcapacity];
			//	//memcpy(tmp, _start, size() * sizeof(T));
			//	//delete[] _start;
			//	//_start = tmp;
			//	//_finish = tmp + old_size;//？
			//	_finish = tmp + size（）;//？
			//	【问题一：此时注意：size是通过start和finish计算的，此时start更新了，所以会导致出现问题】
			//	//_endofstorage = tmp + newcapacity;
			//}
			//*_finish = val;
			//++_finish;
		}

		//【pop_back】尾删
		void pop_back()
		{
			iterator pos = end() - 1;
			erase(pos);
			/*assert(!empty());
			--_finish;*/
		}

		void insert(iterator pos,const T& val)
			//注意这里与string中不同，string中pos用的是下标
			//但是vector用的是迭代器——指针（一个一个单位的内存编号是地址，不可能为0）

		{
			//判断位置是否合法
			assert(pos>=_start);
			assert(pos <= _finish);
			//判断是否需要扩容
			if (size() == capacity())
			{
				size_t len = pos - _start;
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
				//【insert迭代器失效】——reserve之后pos的位置没有更新
				pos = _start + len;
			}
			iterator it = _finish - 1;
			while (it >= pos)
			{
				*(it + 1) = *it;
				--it;
			}
			*pos = val;
			_finish++;
		}

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

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

	private:
		iterator _start = nullptr;
		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++)
		{
			std::cout << v[i] << " ";
		}
		std::cout << std::endl;

		【错误写法】vector<T>::const_iterator it = v.begin();
		【原因】——此时vector<T>还未实例化，所以编译器不敢找const_iterator
		【正确写法】typename——也是typename与class之间的唯一区别
		//typename vector<T>::const_iterator it = v.begin();
		//
		【typename vector<T>::const_iterator it = v.begin();】——typename告诉编译器vector<T>::const_iterator是一个类型
		 先去编译，编译结束之后，实例化之后，再去找
		auto it = v.begin();
		//while (it != v.end())
		//{
		//	std::cout << *it << " ";
		//	it++;
		//}
		//std::cout << std::endl;

		//for (auto& e : v)
		//{
		//	std::cout << e << " ";
		//}
		//std::cout << std::endl;
	}

}