vector模拟实现

其他 2021-11-21 07:20:46 阅读次数: 0

文章目录

一.vector接口总览

namespace lyp
{
    
    
	//模拟实现vector
	template<class T>
	class vector
	{
    
    
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		//默认成员函数
		vector();                                           //构造函数
		vector(size_t n, const T& val);                     //构造函数
		template<class InputIterator>                      
		vector(InputIterator first, InputIterator last);    //构造函数
		vector(const vector<T>& v);                         //拷贝构造函数
		vector<T>& operator=(const vector<T>& v);           //赋值运算符重载函数
		~vector();                                          //析构函数

		//iterator
		iterator begin();
		iterator end();
		const_iterator begin()const;
		const_iterator end()const;

		//capacity
		size_t size()const;
		size_t capacity()const;
		void reserve(size_t n);
		void resize(size_t n, const T& val = T());
		bool empty()const;

		//modifiers
		void push_back(const T& x);
		void pop_back();
		void insert(iterator pos, const T& x);
		iterator erase(iterator pos);
		void swap(vector<T>& v);

		//access
		T& operator[](size_t i);
		const T& operator[](size_t i)const;

	private:
		iterator _start;        //指向容器的头
		iterator _finish;       //指向有效数据的尾
		iterator _endofstorage; //指向容器的尾
	};
}

在这里插入图片描述

二.vector模拟实现

默认成员函数

构造函数

(1). 构造函数1

构造一个空vector，size 和 capacity 为 0，将 _start，_finish， _endofstorage 都置为空指针即可

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

(2). 构造函数2

用 n 个 val 值进行初始化，可以复用 resize 接口，但要注意调用resize()接口需要计算size()和capacity()，所以要将成员变量进行初始化

vector(size_t n, const T& val = T())
// 调用resize()接口需要计算size()和capacity()，所以要进行初始化
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
    
    
		resize(n,val);
}

(3). 构造函数3

用一段迭代器区间进行初始化，由于不同类型的容器迭代器类型可能不同，因此设计成函数模板，将区间内的内容尾插入vector即可，但注意调用push_back接口通过 _finish == _endofstorage 判断是否满，需要初始化

template<class InputIterator>
vector(InputIterator first, InputIterator last)
// 调用push_back接口通过 _finish == _endofstorage 判断是否满，需要初始化
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
    
    
	while (first != last)
	{
    
    
		push_back(*first);
		++first;
	}
}

注意 : 构造函数3和构造函数2写在一起时，那么如果按照下面这样构造会优先调用函数模板，会因为对int类型解引用而报错，所以我们还应该重载两个版本

vector<int> v(10,5);

vector(int n, const T& val = T())
// 调用resize()接口需要计算size()和capacity()，所以要进行初始化
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
    
    
		resize(n,val);
}
vector(long n, const T& val = T())
// 调用resize()接口需要计算size()和capacity()，所以要进行初始化
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
    
    
		resize(n,val);
}

拷贝构造函数

传统写法 :
1). 新开辟一块和 v 同样容量的空间，更新 _start， _finish， _endofstorage
2). 将 v 中的数据拷贝到新开辟的空间中

//传统写法
vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
    
    
	_start = new T[v.capacity()]; //开辟一块和容器v大小相同的空间
	for (size_t i = 0; i < v.size(); i++) //将容器v当中的数据一个个拷贝过来
	{
    
    
		_start[i] = v[i];
	}
	_finish = _start + v.size(); //容器有效数据的尾
	_endofstorage = _start + v.capacity(); //整个容器的尾
}

注意 : 不要使用memcpy函数拷贝数据，如果数据是内置类型或浅拷贝的自定义类型，使用memcpy是没有什么问题的，但如果数据是需要深拷贝的自定义类型(string)，问题就出现了，拷贝的数据和源数据指向同一块空间
在这里插入图片描述

因此，我们使用for循环依次赋值，调用string的赋值运算符重载完成深拷贝
在这里插入图片描述

现代写法 :

使用范围for进行遍历，变量e是v中元素的拷贝，如果v中元素是需要深拷贝的自定义类型，会调用拷贝构造函数构造e，从而使e和v中元素所指向的空间不一样 (auto& e : v 也可以，因为push_back在实现的时候还会调用深拷贝类型的赋值运算符重载)

//现代写法
vector(const vector<T>& v)
	:_start(nullptr)
	, _finish(nullptr)
	, _endofstorage(nullptr)
{
    
    
	reserve(v.capacity()); //调用reserve函数将容器容量设置为与v相同
	for (auto e : v) //将容器v当中的数据一个个尾插过来
	{
    
    
		push_back(e);
	}
}

赋值运算符重载

传统写法
1).释放原空间，新开一块容量和v一样大的空间，更新_start，_finish， _endofstorage
2).将v中的数据拷贝到新空间中

注意 : 不能使用memcpy进行拷贝

vector<T>& operator=(const vector<T>& v)
{
    
    
	if (this != &v)
	{
    
    
		delete[]_start; // 释放原空间
		_start = new T[v.capacity()]; // 开辟新空间
		for (size_t i = 0; i < v.size(); i++) // 拷贝数据
		{
    
    
			_start[i] = v[i];
		}
		_finish = _start + v.size(); // 更新_finish
		_endofstorage = _start + v.capacity(); // 更新_capacity
	}
	return *this;
}

现代写法
1).调用拷贝构造函数生成tmp对象
2).分别交换tmp和this的_start，_finish， _endofstorage

vector<T>& operator=(const vector<T>& v)
{
    
    
	if (this != &v) // 防止自己给自己赋值
	{
    
    
		vector<T> tmp(v); // 拷贝构造tmp对象
		swap(tmp); // 交换_start，_finish， _endofstorage
	}
	return *this;
}
vector<T>& operator=(vector<T>& v) // 拷贝构造v对象
{
    
    
	swap(v); // 交换_start，_finish， _endofstorage
	return *this;
}

析构函数

1). 判断容器是否为空，若为空无需析构
2). 若不为空，将空间释放掉，_start，_finish， _endofstorage置为空指针

~vector()
{
    
    
	// 不为空，空间释放掉
	if (_start)
	{
    
    
		delete[]_start;
	}
	// _start，_finish， _endofstorage置为空指针
	_start = _finish = _endofstorage = nullptr;
}

iterator

begin/end

begin()返回第一个元素的地址，end()返回最后一个元素下一位置的地址，为了能够让const对象调用，加入const版本的begin()和end()

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

capacity

size

返回容器中有效数据的个数，用 _finish - _start 即可

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

capacity

返回容器的容量，用_endofstorage - _start 即可

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

reserve

1). 当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2). 当n小于对象当前的capacity时，什么也不做。

实现步骤
1). 新开辟一块空间，若容器为空，将_start，_finish指向新开辟空间的首元素地址， _endofstorage指向新开辟空间的最后一个元素下一个位置
2). 若容器不为空，将数据拷贝到新空间，释放掉旧空间，更新_start，_finish， _endofstorage的位置

注意 : 将数据拷贝到新空间，仍然不能用memcpy函数，因为对于需要深拷贝的自定义类型，使用memcpy函数以后，新开辟空间里的元素和原空间里的元素所指向的内存空间是一样的，当旧空间被释放时，会调用自定义类型的析构函数，从而使得新开辟空间里的元素指向的内存空间也被释放掉了
在这里插入图片描述

void reserve(size_t n)
{
    
    
	if (n > capacity())
	{
    
    
		T* tmp = new T[n]; // 新开辟一块空间
		// 容器不为空
		if (_start)
		{
    
    
			size_t sizecp = size(); // 计算原来容器size个数
			for (size_t i = 0; i < size(); i++) // 拷贝数据
			{
    
    
				tmp[i] = _start[i];
			}
			delete[]_start; // 释放旧空间
			_start = tmp; // 更新_start
			_finish = _start + sizecp; // 更新_finish
			_endofstorage = _start + n; // 更新_endofstorage
		}
		// 容器为空，更新_start，_finish，_endofstorage的位置
		else
		{
    
    
			_start = _finish = tmp;
			_endofstorage = _start + n;
		}
	}
}

resize

1). 当 n < size 时，直接将 _finish = _start + n (将有效数据长度缩小)即可
(2).当 size < n <= capacity 时，我们将有效数据的长度增加到 n，增加出来的有效数据内容是val
(3).当 n > capacity时，先调用上面的 reserve 函数进行增容，再将有效数据的长度增加到 n，增加出来的有效数据内容是val

void resize(size_t n,const T& val = T())
{
    
    
	// 第一种 n < size()
	if (n < size())
	{
    
    
		_finish = _start + n;
	}
	// n > size()
	else
	{
    
    
		// 增容
		if (n > capacity())
			reserve(n);
		// 填充数据val
		size_t count = n - size();
		while (count--)
		{
    
    
			*_finish = val;
			++_finish;
		}
	}
}

empty

判断 size() == 0 即可

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

modifiers

push_back

尾插入数据，首先要检查是否已满，已满则进行增容，增容后尾插即可

void push_back(const T& val)
{
    
    
	// 增容
	if (_finish == _endofstorage)
	{
    
    
		size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
		reserve(newcapacity);
	}
	// 尾插入数据
	*_finish = val;
	// 使 size++
	++_finish;
}

pop_back

尾删时，首先要判断容器是否为空，若为空，则断言报错，不为空，_finish-- 即可

void pop_back()
{
    
    
	assert(!empty()); // 断言处理
	--_finish;
}

insert

1). 容量不够，先增容，增容之前先记录下 pos - _start 的值，否则增容之后，pos 还指向原来已经被释放的空间
2). 将 pos 位置往后的数据往后挪动一位，在pos位置插入值val

void insert(iterator pos, const T& val)
{
    
    
	// 增容
	if (_finish == _endofstorage)
	{
    
    
		// 记录pos相对于_start的位置
		size_t poscp = pos - _start;
		reserve(capacity() == 0 ? 4 : capacity() * 2);
		// 更新pos位置
		pos = _start + poscp;
	}
	// 挪动pos位置后的数据
	for (iterator i = _finish - 1; i != pos; i--)
	{
    
    
		*(i + 1) = *i;
	}
	// 在pos位置插入值val
	*pos = val;
	// 使size++
	++_finish;
}

erase

容器若为空，则做断言处理，若不为空，将pos位置往后的数据向前挪动一位

iterator erase(iterator pos)
{
    
    
	// 断言
	assert(!empty());
	// 将pos位置往后的数据向前挪动一位
	for (iterator i = pos + 1; i != _finish; i++)
	{
    
    
		*(i - 1) = *i;
	}
	// --size
	--_finish;
	// 返回删除数据的下一个位置
	return pos;
}

access

operator[]

返回底层数组对应位置的引用即可

T& operator[](size_t i)
{
    
    
	// 检查下标有效性
	assert(i < size());
	// 返回对应位置的引用
	return _start[i];
}
const T& operator[](size_t i)const
{
    
    
	// 检查下标有效性
	assert(i < size());
	// 返回对应位置的引用
	return _start[i];
}

猜你喜欢

转载自blog.csdn.net/DR5200/article/details/119607819
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022