C++使用内置容器实现自定义容器

#ifndef _myset
#define _myset
#include<iostream>
#include<set>
using namespace std;


//基于set容器来实现MySet自定义容器
//参数1为 里面存的数据类型    参数2 用哪种容器来实现，并且默认为set容器
/*
* 注:
		在模板(template)中使用一个嵌套从属类型名称, 需要在前一个位置, 添加关键字。
		就是在这个容器中使用另一个容器，当用类名调用的时候要加上前缀typename
*/
template<class _ty,class _container = set<_ty>>
class MySet
{
public:

	//重命名——便于书写
	typedef MySet<_ty, _container> _MySet;




	//用基于的容器来初始化咱们这个MySet容器
	MySet() :c()
	{

	}
	~MySet()
	{

	}
	//拷贝构造函数-根据传进来的MySet容器
	MySet(const  _MySet& _Right) :c(_Right.c)
	{

	}
	//拷贝构造函数-根据传进来的容器种类
	MySet(const _container* _Left) :c(_Left)
	{

	}
	//重载赋值运算符
	_MySet& operator=(const _MySet& _Right)
	{
		this->c = _Right.c;
		return *this;
		//返回引用-内容-所以要*this指针得到内容并返回
	}
	//插入元素-调用set容器-用返回值判断是否插入成功
	bool insert(const _ty& _Val)
	{
		pair<typename _container::iterator, bool>ret = c.insert(_Val);
		if (ret.second)
		{
			cout << _Val << "插入成功" << endl;
			return true;
		}
		else
		{
			cout << _Val << "插入失败" << endl;
			return false;
		}
	}

	//检查容器是否为空-直接调用set容器接口
	bool empty()const
	{
		return c.empty;
	}
	//删除操作-直接调用set容器接口来判断
	bool erase(const _ty& _Val)
	{
		if (c.erase(_Val) > 0)//存在并删除成功返回删除元素的个数，反之返回0
		{
			return true;
		}
		return false;
	}
	//当前容器长度-直接调用set容器接口
	int size()const
	{
		return c.size();
	}
	//得到当前容器的最大值-因为是有以set容器实现的，第一个是最小的，最后一个是最大的
	//返回对组的用处在这里体现了，对组中可以存一个值+一个bool，来判断是否成功。
	pair<_ty, bool> GetMax()const
	{
		pair<_ty, bool>ret;
		typename _container::iterator max = c.end();
		//先判断容器中是否有东西
		if (c.size() > 0)
		{
			ret.first = *(--max);
			ret.second = true;
			return ret;
		}
		else
		{
			ret.second = false;
			return ret;
		}
	}
	//得到最小值
	//核心容器的::value_type 和_ty-传进来的数据类型相同
	pair<_ty, bool> GetMin()const
	{
		pair<_ty, bool>ret;
		typename _container::iterator min = c.begin();
		//判断是否存在
		if (min != c.end())
		{
			ret.first = *c.begin();
			ret.second = true;
			return ret;
		}
		else
		{
			ret.second = false;
			return ret;
		}

	}
	void print()const
	{
		for (typename _container::iterator it = c.begin(); it != c.end(); it++)
		{
			cout << *it << " ";
		}
		cout << endl;
	}

protected:
	//基于哪种容器实现
	_container c;
};

#endif

#include<iostream>
#include"MySet.hpp"
using namespace std;
int main(void)
{
	MySet<int>ms1;
	ms1.insert(5);
	ms1.insert(15);
	ms1.insert(25);

	pair<int,bool>ret = ms1.GetMax();
	if (ret.second)
	{
		cout <<"找到了，最大值是:" << ret.first << endl;
	}
	else
	{
		cout << "找不到" << endl;
	}

	pair<int, bool>ret2 = ms1.GetMin();
	if (ret2.second)
	{
		cout << "找到了，最小值是:" << ret2.first << endl;
	}
	else
	{
		cout << "找不到" << endl;
	}

	ms1.print();

	MySet<int>ms2(ms1);
	ms2.print();

	ms2.erase(15);

	MySet<int>ms3;
	ms3 = ms2;
	ms3.print();

	return 0;
}

#ifndef _SIZEFILTER
#define _SIZEFILTER

#include<iostream>
#include<set>


template<class _Ty,class _Container = set<_Ty>>//第二个模板参数是默用set容器来实现这个新容器的功能
class sizeFilter
{
public:
	typedef sizeFilter<_Ty, _Container> _Myt;
	/*
		在模板(template)中使用一个嵌套从属类型名称, 需要在前一个位置, 添加关键字。
		就是在这个容器中使用另一个容器，当前类容器时模板，要加上前缀typename
	*/

	//用核心容器中的类型(用set容器中的size_type 来当我们这个新容器的size_type)
	typedef typename _Container::size_type size_type;
	typedef typename _Container::value_type value_type; 
	sizeFilter() :c()
	{
		//默认构造函数。初始化内置容器
	}

	sizeFilter(const _Myt& _Right) :c(_Right.c)
	{
		//构造函数，通过指定特定的sizeFilter容器构造
	}

	sizeFilter(const _Container& _Cont) :c(_Cont)
	{
		//构造函数，通过指定特定的容器构造

	}
	_Myt& operator= (const _Myt& _Right)
	{
		//使用sizefilter给另一个sizefilter赋值
		c = _Right.c;
		return (*this);
	}

	bool empty()const
	{
		//用核心容器的功能
		return c.empty();
	}

	size_type size()const
	{
		return c.size();
	}

	bool insert(const value_type& _Val)
	{
		_Container::iterator ci = c.insert(c.begin(), _Val);
		if (ci != c.end())
		{
			std::cout << "插入:" << _Val << "成功" << std::endl;
			return true;
		}
		std::cout << "插入:" << _Val << "失败" << std::endl;
	}

	bool erase(const value_type& _Val)
	{
		if (c.erase(_Val) > 0)
		{
			return true;
		}
		return false;
	}

	//set容器自动排序,默认升序排列，第一个为min,最后一个为max
	std::pair<value_type, bool> getMin()//获取最小值
	{
		std::pair<value_type, bool> ret;
		typename _Container::iterator min = c.begin();
		if (min != c.end())//存在最小值
		{
			ret.first = *min;
			ret.second = true;
			return ret;
		}
		ret.second = false;
		return ret;
	}

	std::pair<value_type, bool> getMax()//获取最大值
	{
		std::pair<value_type, bool>ret;
		typename _Container::iterator max = c.end();
		if (c.size() > 0)//只要容器不是空的，里面就能取到最大值
		{
			ret.first = *(--max);
			ret.second = true;
			return ret;
		}
		ret.second = false;
		return ret;
	}


protected:
	_Container c;//基于哪个容器实现的，这个c就是什么类型的容器
}; 

#endif

#include<iostream>
#include"SizeFilter.hpp"
#include<string>
#include<set>
using namespace std;
int main(void)
{
	sizeFilter<int> sf;
	//插入
	sf.insert(5);


	pair<sizeFilter<int>::value_type, bool>ret = sf.getMax();
	if (ret.second)
	{
		cout <<"最大值是:" <<ret.first<< endl;//看迭代器里面是什么内容来决定操作
	}
	else
	{
		cout << "没找到" << endl;
	}


	pair<sizeFilter<int>::value_type, bool>ret2 = sf.getMin();
	if (ret2.second)
	{
		cout << "最小值是:" << ret.first << endl;
	}
	else
	{
		cout << "没找到" << endl;
	}


	return 0;
}