模拟实现vector类

文章目录

  • 一.定义vector类
  • 二.成员函数的实现
    • 1.构造函数&析构函数
      • ①.构造函数
      • ②.析构函数
    • 2.迭代器
    • 3.size&capacity函数
    • 4.reserve扩容函数
      • 关于reserve中的深浅拷贝问题
    • 5.resize扩容并初始化
    • 6.push_back尾插 pop_back尾删
    • 7.insert——插入
    • 8.erase——删除
    • 9.empty——判空
    • 10.[]重载——访问元素
    • 11.赋值重载
    • 12.拷贝构造
      • 拷贝构造中的深浅拷贝问题
  • 三.源码

一.定义vector类

C++中,STL(Standard Template Library)提供了一个名为vector的容器类,它是一个动态数组,能够存储同一类型的元素。vector的实现在底层使用了动态内存分配和内存管理技术,因此它能够自动调整大小,并且可以高效地插入和删除元素。

vector提供了许多成员函数,如push_back()pop_back()at()front()back()等,这些函数可以用来操作vector中的元素。vector还支持迭代器,可以使用迭代器来访问vector中的元素。此外,vector还支持一些算法,如sort()find()count()等,可以方便地对vector中的元素进行排序、查找和计数等操作。

vectorC++ STL中最常用的容器之一,它可以代替数组,提供了更方便、更安全的操作方式,并且在插入和删除元素时不需要手动管理内存,因此被广泛应用于各种场景。

为了区别于标准库中的vector,我们可以使用自己的命名空间,在自己的命名空间中模拟实现vector

STL源码中,vector包含三个基本成员:

  • iterator _start:指向首元素的迭代器;
  • iterator _finish:指向尾元素下一位的迭代器;
  • iterator _end_of_storage:指向最大容量的下一位的迭代器;

我们可以把迭代器理解为像指针一样的东西:

namespace dianxia
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

二.成员函数的实现

1.构造函数&析构函数

①.构造函数

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

传值构造

	vector<int> v1(10, 5); //用10个5来构造
	vector(size_t n, const T& val = T())
		:_start(nullptr),
		_finish(nullptr),
		_end_of_storage(nullptr)
	{
		//扩容
		reserve(n);
		//尾插
		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}
	//重载版本,防止调用时与迭代器区间构造混淆
	vector(int n, const T& val = T())
		:_start(nullptr),
		_finish(nullptr),
		_end_of_storage(nullptr)
	{
		reserve(n);

		for (size_t i = 0; i < n; i++)
		{
			push_back(val);
		}
	}

迭代器区间构造

vector<int> v1(10, 5); 
vector<string> v2(v1.begin(), v1.end()); //迭代器区间构造
template<class InputIterator>
vector(InputIterator begin, InputIterator end)
{
	//扩容
	reserve(end - begin);
	while (begin != end)
	{
		push_back(*begin);
		++begin;
	}
}

②.析构函数

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

2.迭代器

	iterator begin()
	{
		return _start;
	}
	
	iterator end()
	{
		return _finish;
	}
	
	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _finish;
	}

3.size&capacity函数

	size_t size() const
	{
		return _finish - _start; //指针相减即为元素个数
	}

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

4.reserve扩容函数

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			size_t sz = size();
			//使用中间变量,防止new失败
			iterator tmp = new T[n];
			if (_start)
			{
				//转移数据
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}
				//释放旧空间
				delete[] _start;
			}
			//指向新空间
			_start = tmp;
			_finish = _start + sz;
			_end_of_storage = _start + n;
		}
	}

关于reserve中的深浅拷贝问题

reserve的实现中,我们不能使用memcpy来拷贝数据,否则会发生浅拷贝的问题,导致在析构报错。对于简单的内置类型或自定义类型,memcpy是一个不错的选择,既高效又实用。但是一旦元素涉及到资源申请,memcpy只是简单的将一个元素的值拷贝给另一个元素,并不会将该元素指向的空间的内容全部拷贝给另一个元素。所以,我们必须手动实现深拷贝。

下面代码是错误示例:

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			size_t sz = size();
			//使用中间变量,防止new失败
			iterator tmp = new T[n];
			if (_start)
			{
				//浅拷贝
				memcpy(tmp, _start, sizeof(T)*size());
				delete[] _start;
			}
			//指向新空间
			_start = tmp;
			_finish = _start + sz;
			_end_of_storage = _start + n;
		}
	}

5.resize扩容并初始化

	void resize(size_t n, T val = T())
	{
		//n
		if (n < size())
		{
			_finish = _start + n;
		}
		else
		{
			if (n > capacity)
				reserve(n); //扩容
			while (_finish != _start + n)
			{
				//初始化
				*_finish = val;
				++_finish;
			}
		}
	}

6.push_back尾插 pop_back尾删

	void push_back(const T& val)
	{
		//扩容
		if (_finish == _end_of_storage)
		{
			reserve(capacity() == 0 ? 4 : capacity() * 2);
		}
		//插入元素
		*_finish = val;
		++_finish;
	}
	void pop_back()
	{
		assert(!empty());
		--_finish;
	}

7.insert——插入

	iterator insert(iterator pos,T val=T()) //使用匿名构造
	{
		assert(pos >= _start);
		assert(pos <= _finish);
		//扩容
		if (_finish == _end_of_storage)
		{
			size_t len = pos - _start;
			reserve(capacity() == 0 ? 4 : capacity() * 2);
			//扩容后更新pos的位置,解决迭代器失效的问题
			pos =_start + len;
		}
		//挪动数据
		iterator end = _finish-1;
		while (end >= pos)
		{
			*(end + 1) = *end;
			--end;
		}
		//插入元素
		*pos = val;
		++_finish;
		
		return pos;
	}

8.erase——删除

	iterator erase(iterator pos)
	{
		assert(pos >= _start);
		assert(pos < _finish);
		//挪动数据
		iterator end = pos + 1;
		while (end != _finish)
		{
			*(end - 1) = *end;
			++end;
		}
		--_finish;
		return pos;
	}

9.empty——判空

	bool empty()
	{
		return size() == 0;
	}

10.[]重载——访问元素

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

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

11.赋值重载

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

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

12.拷贝构造

	vector(const vector<T>& v)
	{
		//写法1
		//_start = new T[v.capacity()];
		//for (size_t i = 0; i < v.size(); i++)
		//{
		//	_start[i] = v._start[i];
		//}

		//_finish = _start + v.size();
		//_end_of_storage = _start + v.capacity();

		//写法2
		vector<T> tmp(v.begin(), v.end());
		swap(tmp);
	}

拷贝构造中的深浅拷贝问题

在写法1中,如果使用memcpy,同样会发生浅拷贝的问题。

错误示例:

		vector(const vector<T>& v)
		{
			_start = new T[v.capacity()];
			//浅拷贝
			memcpy(_start, v._start, sizeof(T)*v.size());
			
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}

三.源码

#include
#include
using namespace std;
namespace dianxia
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

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

		vector(size_t n, const T& val = T())
			:_start(nullptr),
			_finish(nullptr),
			_end_of_storage(nullptr)
		{
			//扩容
			reserve(n);
			//尾插
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		vector(int n, const T& val = T())
			:_start(nullptr),
			_finish(nullptr),
			_end_of_storage(nullptr)
		{
			reserve(n);

			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

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

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

		vector(const vector<T>& v)
		{
			//写法1
			_start = new T[v.capacity()];
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v._start[i];
			}

			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();

			写法2
			//vector tmp(v.begin(), v.end());
			//swap(tmp);
		}


		template<class InputIterator>
		vector(InputIterator begin, InputIterator end)
		{
			reserve(end - begin);
			while (begin != end)
			{
				push_back(*begin);
				++begin;
			}
		}
		
		~vector()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

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

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				//使用中间变量,防止new失败
				iterator tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * size());
					//转移数据
					for (size_t i = 0; i < sz; i++)
					{
						tmp[i] = _start[i];
					}
					//释放旧空间
					delete[] _start;
				}
				//指向新空间
				_start = tmp;
				_finish = _start + sz;
				_end_of_storage = _start + n;
			}
		}

		void resize(size_t n, T val = T())
		{
			//n
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				if (n > capacity)
					reserve(n); //扩容
				while (_finish != _start + n)
				{
					//初始化
					*_finish = val;
					++_finish;
				}
			}
		}
		void push_back(const T& val)
		{
			//扩容
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			//插入元素
			*_finish = val;
			++_finish;
		}

		void pop_back()
		{
			assert(!empty());
			--_finish;
		}

		iterator insert(iterator pos,T val=T()) //使用匿名构造
		{
			assert(pos >= _start);
			assert(pos <= _finish);
			//扩容
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				//扩容后更新pos的位置,解决pos失效的问题
				pos =_start + len;
			}
			//挪动数据
			iterator end = _finish-1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			//插入元素
			*pos = val;
			++_finish;

			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			//挪动数据
			iterator end = pos + 1;
			while (end != _finish)
			{
				*(end - 1) = *end;
				++end;
			}
			--_finish;

			return pos;
		}

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

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

	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}


本文到此结束,码文不易,还请多多支持哦!

你可能感兴趣的:(C++学习,c++,开发语言,vector)