[C++初阶]vector的模拟实现

最新推荐文章于 2024-08-02 20:38:56 发布

Dream_Snowar

最新推荐文章于 2024-08-02 20:38:56 发布

阅读量913

点赞数 9

分类专栏： C++从入门到掌握文章标签： c++ 开发语言 stl

本文链接：https://blog.csdn.net/2301_80017277/article/details/140191220

版权

C++从入门到掌握专栏收录该内容

31 篇文章 0 订阅

订阅专栏

上篇我们实现了STL学习的三步：能用，明理，能扩展中的能用，着篇我们要办到明理。

所以，本篇，我们将会对于vector进行模拟实现。

这里我们采用和之前一样的方法自己开一个命名空间，写出我们自己的vector类

#pragma once
#include<iostream>
using namespace std;
namespace  Myvector
{
	class vector
	{

	};
}

像这样。

一、vector中的成员变量

vector中实际存在三个成员变量吗，分别是_start、_finish、_end_of_storage

_start指向容器的开始位置，_finish指向容器当中有效数据的末尾，_end_of_storage指向容量的末尾。

这三个都是指针，我们用迭代器调用。

但是迭代器在我们自己的命名空间中不存在，我们还是使用之前的string类的模拟实现的办法（因为vector接受的数据类型多，我们这里用了模板）

typedef T* iterator;
typedef const T* const_iterator;

因此类的私有部分是这么写的

namespace  Myvector
{
	template<class T>
	class vector
	{
	public:
		typedef  T* iterator;
		typedef const T* const_iterator ;
	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};
}

二、vector的默认成员函数

1.构造函数

这个是必不可少的一个函数，他还分为不少情况

1）无参构造

这个我们可以直接调用初始化列表来实现

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

2）使用一段迭代器区间进行对象的构造

template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
	//已经在定义的地方赋初始值了,不用走初始化列表
	while (first != last)
	{
		push_back(*first);

		++first;
	}
}

注意：若使用iterator做迭代器，会导致初始化的迭代器区间[first,last)只能是vector的迭代器，重新声明迭代器，迭代器区间[first,last)可以是任意容器的迭代器

如果我们希望可以接收各种类型的迭代器区间的话，我们这里可以将该构造函数设计为一个函数模板，在函数体内将该迭代器区间的数据一个个尾插到容器当中即可，这里不能提前开空间，因为有的迭代器不支持减的操作，比如：list。

3) 对n个值为val的数据的构造

这个很简单的

vector(size_t n, const T& val)
{
	reserve(n);

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

直接尾插拉满,至于尾插,我们之后再写。

值得注意的是，这个函数，我们需要写一个重载函数

vector(int n, const T& val)
{
	reserve(n);

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

这个函数也是必要的，因为再某些情况，如：

vector<int> v(10,5)

当我们这么写的时候，如果我们没有对上免得构造函数进行重载，他会调用使用一段迭代器区间进行对象的构造。

理论上将，提供了vector(size_t n, const T& value = T())之后 vector(int n, const T& value = T())就不需要提供了，但是对于： vector<int> v(10, 5);，编译器在编译时，认为T已经被实例化为int，而10和5编译器会默认其为int类型，就不会走vector(size_t n, const T& value = T())这个构造方法，
最终选择的是：vector(InputIterator first, InputIterator last)，因为编译器觉得区间构造两个参数类型一致，因此编译器就会将InputIterator实例化为int，但是10和5根本不是一个区间，因此编译时就报错了，所以需要加上我们上面的重载函数。

编译器对于函数重载会优先选择最合适的，所以我么那些重载函数的时候一定要记住这点。

2。拷贝构造函数

这东西也分现代写法和传统写法，对此我们写了以下三种写法:

vector(const vector<T>& v)
{
	reserve(v.capacity());
	for (const auto& e : v)
	{
			push_back(e);
	}
}

此写法也比较简单，使用范围for（或是其他遍历方式）对容器v进行遍历，在遍历过程中将容器v中存储的数据一个个尾插过来即可。

注意：在使用范围for对容器v进行遍历的过程中，变量e就是每一个要插入的数据的引用，然后将e尾插到构造出来的容器当中。就算容器v当中存储的数据是string类，在尾插时也会自动调用string的拷贝构造（深拷贝），所以也能够避免出现与使用memcpy时类似的问题。(所以头文件,我们也需要引用string类)

vector(const vector<T>& v)
{
	vector<T> tmp(v.begin(), v.end());

	swap(tmp);
}

这种每升好说的,就是标准的现代写法,构造一个新的vector并存入所需要的值,然后与需要的类交换

vector(const vector<T>& v)
{
		reserve(v.capacity());

		iterator it = begin();
		const_iterator vit = v.begin();//v是const对象,必须用const迭代器接收返回值
		while (vit != v.end())
		{
			*it++ = *vit++;
		}

		_finish = it;
}

3.赋值运算符重载函数

拷贝构造函数的现代写法是通过调用构造函数构造出一个对象，然后将该对象与拷贝对象交换。

vector(const vector<T>& v)
{
	vector<T> tmp(v.begin(), v.end());

	swap(tmp);
}

4.析构函数

先释放容器存储数据的空间，然后将容器的各个成员变量设置为空指针即可。

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

5.迭代器相关函数

这里vector当中的迭代器使用的时原生指针。(我们上面说过的)

typedef T* iterator;
typedef const T* const_iterator;

6.begin和end

string类中的begin和end函数很简单，begin函数用来返回字符串中第一个字符的地址。

iterator begin()
{
	return _start;
}

iterator end()
{
	return _finish;
}

还有一组const对象的版本，使得const对象调用begin和end函数时所得到的迭代器只能对数据进行读操作，而不能进行修改。

const_iterator begin() const
{
	return _start;
}

const_iterator end() const
{
	return _finish;
}

7.容量和大小及其相关函数

1)size和capacity

两个指针相减的结果，就是这两个指针之间对应类型的数据个数

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

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

3)empty 和 swap

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

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

4)clear 和 shrink_to_fit

void clear()
{
	_finish = _start;
}

void shrink_to_fit()
{
	size_t sz = size();

	T* tmp = new T[sz];
	
	if (_start)
	{
		for (size_t i = 0; i < sz; i++)
		{
			tmp[i] = _start[i];
		}

		delete[] _start;
	}

	_start = tmp;
	_finish = _end_of_storage = _start + sz;
}

8.reserve

eserve规则：
1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，什么也不做。

void reserve(size_t n)
{
	size_t sz = size();

	if (n > capacity())
	{
		T* 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;
	}
}

在进行操作之前需要提前记录当前容器当中有效数据的个数，因为扩容_start发生改变，size算出来的结果就是错误的。

拷贝容器当中的数据时，不能使用memcpy函数进行拷贝，否则内部就是浅拷贝，memcpy只是把值拷贝过来。

当执行 delete[ ] _start的时候会把原来空间里面的值释放，因为浅拷贝，导致扩容之后的空间里面的对象里面都是随机值。

9.resize

resize规则：
1、当n大于当前的size时，将size扩大到n，扩大的数据为val，若val未给出，则默认为容器所存储类型的默认构造函数所构造出来的值。
2、当n小于当前的size时，将size缩小到n。

void resize(size_t n, T val = T())
{
	if (n <= size())
	{
		_finish = _start + n;
	}
	else
	{
		if (n > capacity())
		{
			reserve(n);
		}

		while (_finish != _start + n)
		{
			*_finish = val;
			_finish++;
		}
	}
}

10.push_back 和 pop_back

void push_back(const T& val)
{
	if (_finish == _end_of_storage)
	{
		size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
		reserve(newcapacity);
	}

	*_finish = val;
	++_finish;
}

void pop_back()
{
	assert(!empty());

	--_finish;
}

11.insert

insert函数可以在所给迭代器pos位置插入数据，在插入数据前先判断是否需要增容，然后将pos位置及其之后的数据统一向后挪动一位，以留出pos位置进行插入，最后将数据插入到pos位置即可。

iterator insert(iterator pos,const T& val)
{
	assert(pos >= _start);
	assert(pos <= _finish);

	if (_finish == _end_of_storage)
	{
		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 = val;
	++_finish;

	return pos;
}

12.erase

erase函数可以删除所给迭代器pos位置的数据，在删除数据前需要判断容器释放为空，若为空则需做断言处理，删除数据时直接将pos位置之后的数据统一向前挪动一位，将pos位置的数据覆盖即可。

iterator erase(iterator pos)
{
	assert(pos >= _start);
	assert(pos < _finish);
	
	iterator start = pos + 1;

	while (start < _finish)
	{
		*(start - 1) = *start;
		++start;
	}

	--_finish;

	return pos;
}

因此所有代码为:

#include <assert.h>
#include <iostream>
#include <vector>

using namespace std;

namespace Myvector
{
	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() = default;

		/*vector(const vector<T>& v)
		{
			reserve(v.capacity());

			for (const auto& e : v)
			{
				push_back(e);
			}
		}*/

		vector(const vector<T>& v)
		{
			vector<T> tmp(v.begin(), v.end());

			swap(tmp);
		}

		vector<T>& operator=(vector<T> v)
		{
			swap(v);

			return *this;
		}

		vector(size_t n, const T& val)
		{
			reserve(n);

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

		vector(int n, const T& val)
		{
			reserve(n);

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

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

				++first;
			}
		}

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

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

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

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

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

		void clear()
		{
			_finish = _start;
		}

		void shrink_to_fit()
		{
			size_t sz = size();

			T* tmp = new T[sz];
			
			if (_start)
			{
				for (size_t i = 0; i < sz; i++)
				{
					tmp[i] = _start[i];
				}

				delete[] _start;
			}

			_start = tmp;
			_finish = _end_of_storage = _start + sz;
		}

		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)
		{
			size_t sz = size();

			if (n > capacity())
			{
				T* 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;
			}
		}

		void resize(size_t n, T val = T())
		{
			if (n <= size())
			{
				_finish = _start + n;
			}
			else
			{
				if (n > capacity())
				{
					reserve(n);
				}

				while (_finish != _start + n)
				{
					*_finish = val;
					_finish++;
				}
			}
		}

		template <class InputIterator>
		void assign(InputIterator first, InputIterator last)
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
			
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		void assign(size_t n, const T& val)
		{
			reserve(n);

			T* tmp = new T[n];
			for (size_t i = 0; i < n; i++)
			{
				tmp[i] = val;
			}
			_start = tmp;

			_finish = _end_of_storage = _start + n;
		}

		void assign(int n, const T& val)
		{
			reserve(n);

			T* tmp = new T[n];
			for (int i = 0; i < n; i++)
			{
				tmp[i] = val;
			}
			_start = tmp;

			_finish = _end_of_storage = _start + n;
		}

	/*	void assign(size_t n, const T& val)
		{
			reserve(n);

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

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

		void push_back(const T& val)
		{
			if (_finish == _end_of_storage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : 2 * capacity();
				reserve(newcapacity);
			}

			*_finish = val;
			++_finish;
		}

		void pop_back()
		{
			assert(!empty());

			--_finish;
		}

		iterator insert(iterator pos,const T& val)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			if (_finish == _end_of_storage)
			{
				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 = val;
			++_finish;

			return pos;
		}

		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);
			
			iterator start = pos + 1;

			while (start < _finish)
			{
				*(start - 1) = *start;
				++start;
			}

			--_finish;

			return pos;
		}
	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};
}

Dream_Snowar

关注

9
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
[C++初阶]vector的模拟实现

上篇我们实现了STL学习的三步：能用，明理，能扩展中的能用，着篇我们要办到明理。所以，本篇，我们将会对于vector进行模拟实现。这里我们采用和之前一样的方法自己开一个命名空间，写出我们自己的vector类像这样。
复制链接

扫一扫

专栏目录