【1++的C++初阶】之适配器

👍作者主页:进击的1++

🤩 专栏链接:【1++的C++初阶】

文章目录

一,什么是适配器

适配器作为STL的六大组件之一,其本质是一种设计模式,将一个class的接口转换为另一个class的接口。比如说我们接下来要进行模拟实现的stack。若是以vector为底层,其实就是对vector接口的再次封装。因此其虽然也能够存储数据,但在STL中其却不属于容器。

二,栈与队列模拟实现

栈与队列的详细剖析与说明在前面的【1++的数据结构初阶】中已经写过有关文章。若有疑惑可移步至专栏中查看。本篇中进行的实现主要基于适配器的设计模式,因此底层较为简单。
栈的实现

cpp 复制代码
template <class T,class container=std::deque<T>>
	class stack
	{
	public:
		void push(const T& val)
		{
			_con.push_back(val);
		}

		T& top()
		{
			return _con.back();
		}

		void pop()
		{
			_con.pop_back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.emnpty();
		}


	private:
		container _con;
	};

队列的实现

cpp 复制代码
template<class T,class container=std::deque<T>>
	class queue
	{
	public:

		void push(const T& val)
		{
			_con.push_back(val);
		}

		void pop()
		{
			_con.pop_front();
		}

		T& front()
		{
			return _con.front();
		}

		T& back()
		{
			return _con.back();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		container _con;
	};

可能有人会疑惑,模板中的container是什么鬼?

来,让我们看看官方的解释:

其就是存储元素的内部容器的类型

在直接点就是成员类型。例如:stack中的成员------_con的类型就为deque。

那么问题来了什么又是deque呢?

接下来我们对deque进行一个简单的介绍了。

deque是一种双端队列,其可以在头尾进行插入和删除,并且时间复杂度为O(1)。与vector相比,其可以进行头插与头删;与list相比,其对数据的随机访问的效率高。

是不是对deque的底层实现越发的好奇了。

让我们来解开这层神秘的面纱。

deque的底层空间并不是连续的,而是一个个小块。类似于二维数组一样。

之所以选择deque作为栈和队列的底层默认容器,正是看中了其头尾在进行操作时的高效率。

deque若如此完美,那为什么不大量应用呢?原因在于其也有缺点。

deque在进行遍历时,要经过稍复杂的计算才能够计算出其在哪一块的哪个位置,所以,当数据量大时,其遍历的效率比较低。并且其中间的插入,删除效率也不高。

三,优先级队列

什么是priority_queue(优先级队列)?

它也是一种适配器,其在默认情况下,第一个位置的元素总是最大的。类似于堆。其底层容器的前提是可以通过随机访问迭代器进行随机访问。
priority_queue的实现

cpp 复制代码
template<class T>
	class less
	{
	public:
		bool operator()(const T& left, const T& right)const
		{
			return left < right;
		}
	};


	template<class T>
	class greater
	{
	public:
		bool operator()(const T& left, const T& right)const
		{
			return left > right;
		}
	};

	template<class T,class container=std::vector<T>,class compare=greater<T>>
	class priority_queue
	{
	public:
		
		void adjust_up()
		{
			size_t child = _con.size() - 1;
			size_t parent = (child-1)/2;
			while (child > 0)
			{
				compare com;
				if (com(_con[parent],_con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent=(child - 1) / 2;
				}
				else
				{
					break;
				}
			}


		}

		void adjust_down()
		{
			//默认左孩子为大----大堆前提下
			size_t parent = 0;
			size_t child = parent* 2+1;
			while (child < _con.size())
			{
				compare com;
				if ((child + 1) < _con.size() && com(_con[child], _con[child+1]))
				{
					child++;
				}

				if (com(_con[parent], _con[child]))
				{
					std::swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}

			}
		}
		void push(const T& val)
		{
			//向上调整
			_con.push_back(val);
			adjust_up();
		}

		const T& top()const
		{
			return _con[0];
		}


		void pop()
		{
			std::swap(_con.back(), _con[0]);
			_con.pop_back();
			//向下调整
			adjust_down();
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		container _con;
	};

优先级队列在push建堆时,使用的是向上调整,时间复杂度为O(logN) ,在默认为大堆 的情况下,孩子结点于父亲结点比较,若大于父亲结点,则进行交换,直到小于父亲结点或者到达根节点。

在代码中,我们还发现了其比较大小的写法与以往不同。

这叫做做仿函数,其与普通函数的调用相差不大,但其本质是类对象调用重载后的(),即operator() 。

四,reverse_iterator

反向适配器其底层为正向迭代器。其也是适配器的一种。

具体实现如下:

cpp 复制代码
template<class Iterator,class Ref,class Ptr>
	class reverse_iterator
	{
	public:
		typedef reverse_iterator<Iterator,Ref,Ptr> Riterator;
		
		reverse_iterator(Iterator it)
			:cur(it)
		{}

		Riterator operator++()
		{
			--cur;
			return *this;
		}

		Riterator operator--()
		{
			++cur;
			return *this;
		}

		Ref operator*()
		{
			Iterator tmp = cur;
			--tmp;
			return *tmp;
		}

		Ptr operator->()
		{
			return &(*operator());
		}

		bool operator!=(const Riterator& it)
		{
			return cur != it.cur;
		}

	private:
		Iterator cur;

	};

       reverse_iterator rend()
		{
			return reverse_iterator(begin());
		}

		reverse_iterator rbegin()
		{
			return reverse_iterator(end());
		}

反向迭代器与rbegin(),rend() 进行搭配,通过观察我们发现,其rend(),实际返回的是begin(),rbegin()返回的是end()。恰好对称。并且,反向迭代器中的++,实际上为正向迭代器的- -; --则实际上为++。

需要注意的是operator*()的实现。其返回的是当前迭代器指向的元素的下一个元素(右往左数)。这样做的原因是:end()指向的是最后一个元素的下一位置。并且,由于对称的原因,rbegin指向的位置与end相同,因此在返回其元素的时候,就需要返回其下以位置的元素。

相关推荐
JSU_曾是此间年少3 分钟前
数据结构——线性表与链表
数据结构·c++·算法
此生只爱蛋1 小时前
【手撕排序2】快速排序
c语言·c++·算法·排序算法
何曾参静谧1 小时前
「C/C++」C/C++ 指针篇 之 指针运算
c语言·开发语言·c++
lulu_gh_yu2 小时前
数据结构之排序补充
c语言·开发语言·数据结构·c++·学习·算法·排序算法
ULTRA??3 小时前
C加加中的结构化绑定(解包,折叠展开)
开发语言·c++
凌云行者3 小时前
OpenGL入门005——使用Shader类管理着色器
c++·cmake·opengl
凌云行者3 小时前
OpenGL入门006——着色器在纹理混合中的应用
c++·cmake·opengl
~yY…s<#>4 小时前
【刷题17】最小栈、栈的压入弹出、逆波兰表达式
c语言·数据结构·c++·算法·leetcode
可均可可4 小时前
C++之OpenCV入门到提高004:Mat 对象的使用
c++·opencv·mat·imread·imwrite
白子寰5 小时前
【C++打怪之路Lv14】- “多态“篇
开发语言·c++