vector的使用和底层模拟实现

爱吃喵的鲤鱼

个人主页

文章目录

• 前言
• 一、pandas是什么？
• 二、使用步骤
  • 1.引入库
  • 2.读入数据
• 总结

---

前言

我们已经 学习了string在来实现vector会发现他们两的结构很像，而string只支持存储字符串，vector支持任意类型；

---

一、vector是什么？

vector和string都一样，是c++的容器，两个的差别在于vector存储的是任意类型，string是字符串。底层结构也有所不同，string数据结构和数组相似，而vector使用3个指针控制的。

二、vector的使用

2.常用的函数代码演示

1、迭代器的使用

void func(const vector<int>& vv)
{
	vector<int>::const_iterator it = vv.begin();
	for (size_t i = 0; i < vv.size(); i++)
	{
		cout << vv[i] << " ";
	}
	cout << endl;
	while (it != vv.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	for (auto i : vv)
	{
		cout << i << " ";
	}
	cout << endl;
	
}

其实大家经常使用的范围for也是迭代器的使用；

2、常用的修改器

vector<int> vv;
vv.push_back(1);
vv.push_back(2);
vv.push_back(3);
vv.push_back(4);
vector<int>::iterator pos = find(vv.begin(), vv.end(), 2);
if (pos == vv.end())
{
	vv.insert(pos, 30);
}
for (auto i : vv)//打印元素
{
	cout << i << " ";
}
cout << endl;

vv.resize(20,0);//开20个空间并且初始化
for (auto i : vv)//打印元素
{
	cout << i << " ";
}
cout << endl;
vv.push_back(20);//尾插
for (auto i : vv)//打印元素
{
	cout << i << " ";
}
cout << endl;
vv.pop_back();
vv.pop_back();
vv.pop_back();
for (int i = 0; i < 10; i++)//循环尾删10次
{
	vv.pop_back();
}
for (auto i : vv)//打印元素
{
	cout << i << " ";
}
cout << endl;
auto it = vv.begin();
//删除偶数
while (it != vv.end())
{
	if (*it % 2 == 0)
	{
		it = vv.erase(it);//删除it位置元素

	}
	else
		it++;
}
for (auto i : vv)
{
	cout << i << " ";
}
}

3、容量

已经在上面两类中体现了 

三、底层模拟实现

1、vector构架

	template<class T>//因为vector可以容下任意类型，所以我们构建了一个模板类
class vector
{
public:
	typedef T* iterator;//对迭代器的声名
	typedef const T* const_iterator;//对const迭代器的声名
	vector()//构造函数
		:_start(nullptr)
		, _finish(nullptr)
		, _end_of_storage(nullptr)
	{}
		~vector()//析构函数
		{
			delete[]_start;
			_start = _finish = _end_of_storage = nullptr;
		}
		vector(size_t n,const T& val=T())//构造函数
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{
			
			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)
		{

			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}		
vector(const vector<T>& v)//拷贝构造
		{
			//reserve(capacity());
			_start = new T[capacity()];
			//memcpy(_start, v._start, sizeof(T)*v.size());//
			for (size_t i = 0; i < v.size(); i++)
			{
				_start[i] = v._start[i];
			}
			_finish = _start + v.size();
			_end_of_storage = _start + v.capacity();
		}
private:
		//左闭右开区间
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;
	};

在我们的拷贝构造中涉及了一个深浅拷贝问题；

什么是深浅拷贝 ？

浅拷贝只是对成员变量进行了拷贝 

浅拷贝就是我们只对一块内存空间的地址进行拷贝，这个时候就会有两个指针变量指向了同一块空间，当我们对第一个成员进行析构时，这空空间已经被释放了，第二个变量再来这里析构就会让程序崩溃；

深拷贝是两块不同的空间 

深拷贝是在开辟一块空间，将原有内存中的数据一个个的拷贝到新空间中；

2、vector的迭代器函数

bool empty()//判断是否为空
{
	return _start == _finish;
}
size_t capacity() const
{
	return _end_of_storage - _start;
}
size_t size() const
{
	return _finish - _start;
}
const T& operator[](size_t pos) const
{
	assert(pos < size());
	return _start[pos];
}
size_t capacity()
{
	return _end_of_storage - _start;
}
size_t size()
{
	return _finish - _start;
}
T& operator[](size_t pos)
{
	assert(pos < size());
	return _start[pos];
}
iterator begin()
{
	return _start;
}
iterator end()
{
	return _finish;
}
const iterator begin() const
{
	return _start;
}
const iterator end() const
{
	return _finish;
}

迭代器中判断大小主要用的是地址-地址，因为一段连续的空间，地址-地址就是它的大小；

这些函数在后面使用时，我们会用到const的类型，所以构造了const的函数 

3、修改器的模拟实现

		iterator insert(iterator pos, const 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 = _start + len;
			}
			iterator end = _finish - 1;//没有这个会有迭代器失效，就是构成野指针
			while (end >= pos)
			{
				
				*(end + 1) = *end;
				end--;
			}
			*pos = val;
			_finish++;
			return pos;//以后还可以在次使用
		}

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

		}
		iterator erase(iterator pos)//erase不在访问这块空间
		{
			assert(pos < _finish);
			assert(pos >= _start);
			iterator start = pos + 1;
			while (start != _finish)
			{
				*(start-1) = *start;
				start++;
			}
			_finish--;
			return pos;
		}
	void reserve(size_t n)//开辟n个空间
	{
		if (n > capacity())
		{
			size_t sz = size();
			T* tmp = new T[n];
			if (_start)
			{
				memcpy(tmp, _start, sizeof(T) * size());
			/*	for (size_t i = 0; i < size(); i++)
				{
					_start[i] = tmp[i];
				}*/
				delete[] _start;
			}
			_start = tmp;
			_finish = tmp + sz;
			_end_of_storage = tmp + n;
		}
	}
	void push_back(const T& x)//尾插
	{
		if (_finish == _end_of_storage)
		{
			reserve(capacity() == 0 ? 4 : capacity() * 2);
		}
		*_finish = x;
		_finish++;
	}
	void pop_back()//尾删
	{
		assert(!empty());
		_finish--;
	}

---