@TOC

MySet容器实现

MySet .hpp

#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

main.cpp

#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;
}

SizeFilter容器实现

SizeFilter.hpp

#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

main.cpp

#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;
}