vector的使用及模拟实现（c++）

最新推荐文章于 2024-04-23 15:23:27 发布

墨白1357

最新推荐文章于 2024-04-23 15:23:27 发布

阅读量697

点赞数

文章标签：机器学习开发语言 c++

本文链接：https://blog.csdn.net/weixin_65665343/article/details/126917206

版权

一.STL概述

STL(StandardTemplateLibrary,标准模板库)，是惠普实验室开发的一系列软件的统称。现在主要出现在c++中，但是在引入c++之前该技术已经存在很长时间了。STL从广义上分为:容器(container)算法(algorithm)迭代器(iterator),容器和算法之间通过迭代器进行无缝连接。STL几乎所有的代码都采用了模板类或者模板函数，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。STL(StandardTemplateLibrary)标准模板库,在我们c++标准程序库中隶属于STL的占到了80%以上。

二.STL六大组件

1.容器 2.算法 3.迭代器 4.仿函数 5.适配器 6.空间配置器

文章目录

STL的使用
前言
一、vector是什么？
1.迭代器介绍
二、使用步骤
- 1.vector常见的API
- 2.读入数据
- 3.容器可以套自定义数据
- 4.容器嵌套容器
- 5.vector模拟与实现
总结

提示：以下是本篇文章正文内容，下面案例可供参考

一、vecto是什么？

vector是表示可变大小数组的序列容器。
就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。


#include<vector>//包含vector头文件才能使用
#include<iostream>
#include<algorithm>

using namespace  std;
int main()
{

	vector<int> v;//<int>这是指定的类型可以说double也可以是自定义类型
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	vector<int>::iterator it = v.begin();//定义了一个迭代器it指向初始位置v.begin
	while (it != v.end())//遍历
	{
		cout << *it << endl;//*it就是迭代器的值
		++it;
	}
	cout << endl;

	for_each(v.begin(), v.end(), [](int val) {cout << val << endl; });//系统提供的算法for_each参数为其实迭代器，结束迭代器，需要打印的参数

	return 0;
}

1.迭代器的介绍

二. 迭代器的分类

输入迭代器	提供对数据的只读访问	只读，支持++.==.！=
输出迭代器	提供对数据的只写访问	只写，支持++
前向迭代器	提供读写操作，并能向前推进迭代器	读写，支持++.==.！=
双向迭代器	提供读写操作，并能向前向后操作	读写，支持++.--
随机访问迭代器	提供读写操作，并能以跳跃的方式访问容器的任意数据，是功能最强的迭代器	读写，支持++.--【】.< <= > >=

二、使用步骤

1.vector常见的API



构造函数vector<T> v;//采用模板实现类实现，

默认构造函数

vector(v.begin(),v.end());//将v[begin(),end())区间中的元素拷贝给本身。

vector(n,elem);//构造函数将n个elem拷贝给本身。

vector(constvector& vec);//拷贝构造函数。//例子使用第二个构造函数我们可以...

int arr[]={ 2,3,4,1,9 };

vector<int>v1(arr,arr+sizeof(arr)/sizeof(int));



vector常用赋值操作

assign(beg,end);//将[beg,end)区间中的数据拷贝赋值给本身。

assign(n,elem);//将nelem拷贝赋值给本身。

vector&operator=(constvector& vec);//重载等号操作符

swap(vec);//将vec与本身的元素互换。


vector大小操作

size();//返回容器中元素的个数

empty();//判断容器是否为空

resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

resize(int num,elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。

capacity();//容器的容量

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。

vector
数据存取操作
at(int idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。

operator[];//返回索引idx所指的数据，越界时，运行直接报错

front();//返回容器中第一个数据元素

back();//返回容器中最后一个数据元素


vector插入和删除操作

insert(const_iteratorpos,intcount, ele);//迭代器指向位置pos插入count个元素ele.

push_back(ele);//尾部插入元素ele

pop_back();//删除最后一个元素

erase(const_iterator start,const_iterator end);//删除迭代器从start到end之间的元素

erase(const_iteratorpos);//删除迭代器指向的元素

clear();//删除容器中所有元素

这里列举了大部分的API：建议看官方的文档，这里推荐一个网站这里面有比较全的STL容器api的介绍https://m.cplusplus.com/

3.容器可以套自定义数据


#include<vector>//包含vector头文件才能使用
#include<iostream>
#include<algorithm>
#include<string>

using namespace  std;

class Penson
{
public:
	Penson(string name="里斯", int age=0)
	{
		this->name = name;
		this->age = age;
	}

	string name;
	int age;

};
void text01()
{
	Penson ob1("张三", 18);
	Penson ob2("李四", 19);
	Penson ob3("王五", 20);
	Penson ob4("狂徒", 21);
	
	//定义一个vector<person> v 来存放数据
	vector<Penson> v;
	v.push_back(ob1);
	v.push_back(ob2);
	v.push_back(ob3);
	v.push_back(ob4);
	
	for_each(v.begin(), v.end(), [](Penson& ob1) {cout << "name= " << ob1.name << "age= " << ob1.age; });

}
int main()
{
	text01();
	

	//容器可以嵌套自定义数据



	return 0;
}

4.容器嵌套容器

#include<iostream>
#include"vector.h"
using namespace std;
void text02()
{
	vector<int> v;
	vector<int> v2;
	vector<int> v3;

	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	v2.push_back(10);
	v2.push_back(20);
	v2.push_back(30);
	v2.push_back(40);

	v3.push_back(100);
	v3.push_back(200);
	v3.push_back(300);
	v3.push_back(400);
	//需求定义一个vetor存放v1 v3 v2
	vector<vector<int>> vv;
	vv.push_back(v);
	vv.push_back(v2);
	vv.push_back(v3);

	//遍历
	for (vector<vector<int>>::iterator it = vv.begin(); it != vv.end(); it++)
	{
		for (vector<int>::iterator mit = (*it).begin(); mit != (*it).end(); mit++)
		{
			cout << *mit << " ";
		}
		cout << endl;
	}

}
int main()
{
	/*text01();*/
	text02();

5.vector的模拟与实现

#include <assert.h>
#include<algorithm>
#include<string.h>

namespace zdc
{
	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()//用 n 个 val 值进行初始化，可以复用 resize 接口，但要注意调用resize()接口要
                                     //计算size()和capacity()，所以要将成员变量进行初始化
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}

		vector(const vector<int>& v)
		{
			_start = new T[v.size()];//size和capicaty都可以传统写法和现代写法
			memcpy(_start, v._start, sizeof(T) * v.size());
			_finish = _start + v.size();
			_end_of_storage = _start + v.size();//老空间加上新空间
		}

		~vector()
		{
			delete[] _start;
			_start = _finish = _end_of_storage = nullptr;//删除老空间，新空间初始化为0
		}

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

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

			return _start[pos];
		}

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

			return _start[pos];
		}

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

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					memcpy(tmp, _start, sizeof(T) * sz);
					delete[] _start;
				}

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

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

				*_finish = x;
				++_finish;*/
			insert(end(), x);
		}

		void pop_back()
		{
			assert(_finish > _start);
			--_finish;
		}
		//void insert(iterator pos, const T& x)
		//{
		//	assert(pos >= _start);//判断是不是在这个范围内
		//	assert(pos <= _finish);//=就是尾插
		//	//插入可能空间不足
		//	if (_finish == _end_of_storage)
		//	{
		//		reserve(capacity() == 0 ? 4 : capacity() * 2);
		//		//扩容
		//	}
		//	//挪动数据
		//	iterator end = _finish - 1;//finsh是最后一个位置-1
		//	while (end >= pos)
		//	{
		//		*(end + 1) = *end;//将当前位值向后挪动
		//		--end;
		//	}
		//	*pos = x;//pos位置放进去
		//	++_finish;

		//}

		void insert(iterator pos, const T& x)
		{
			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 = x;

			++_finish;
		}

		// stl 规定erase返回删除位置下一个位置迭代器
		iterator erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);

			iterator begin = pos + 1;
			while (begin < _finish)
			{
				*(begin - 1) = *begin;
				++begin;
			}

			--_finish;
			//if (size() < capacity()/2)
			//{
			//	// 缩容 -- 以时间换空间
			//}

			return pos;
		}

	private:
		iterator _start;
		iterator _finish;
		iterator _end_of_storage;

	};
}