STL set重载比较函数

最新推荐文章于 2023-04-05 15:42:41 发布

shiguojie19892

最新推荐文章于 2023-04-05 15:42:41 发布

阅读量2.3k

点赞数 3

分类专栏：技术文章标签： c++ stl set 排序 class

本文链接：https://blog.csdn.net/shiguojie19892/article/details/40892881

版权

技术专栏收录该内容

4 篇文章 0 订阅

订阅专栏

接触STL以后，就被它的简单易用吸引住了，今天工作中用到了SET关联容器的重载。

在这儿记录下来，也温习一遍。

需求要求打印一组数据，数据结构如下：

struct POIinfo
{
    string NameC;
    int Featcode;
    int MeshID;
    int PoiID;
    bool IsTourClass;
};

我想到把这个POIinfo放到set中，通过迭代器一一打印出来。

打印的排序要求是：

NameC名称一样的排在一起，如果名字一样那么IsTourClass是true 的排在前面。
如果IsTourClass都是true或者false，那么Featcode小的排在前面。
如果Featcode相等，那么MeshID小的排在前面。
如果MeshIDea相等，那么PoiID小的排在前面。

偶然的机会看到set可以重载排序函数（之前一直没有彻底搞清楚什么是重载）

使用bool operator()(const POIinfo& info1,const POIinfo& info2)const   
    {
		return info1.NameC < info2.NameC;
    }
就可以实现重载排序。但是因为不知道其中的因果作用，所以复杂的排序方式，还是没有实现。

我现在的理解是重载后的返回值决定了这个值是排在set的前一个值得前面还是后面，return TRUE 则info1排在前面，反之info2排在前面。

知道了这个规则结合排序原则，那么下面就是：

    bool operator()(const POIinfo& info1,const POIinfo& info2) const   
    {
        // NameC名称一样的排在一起
        if (info1.NameC != info2.NameC)
            return info1.NameC < info2.NameC;

        // 如果名字一样那么IsTourClass是true 的排在前面
        if (info1.IsTourClass == true && info2.IsTourClass == false)
            return true;
        if (info1.IsTourClass == false && info2.IsTourClass == true)
            return false;

        // 如果IsTourClass都是true或者false，那么Featcode小的排在前面
        if (info1.Featcode != info2.Featcode)
            return info1.Featcode < info2.Featcode;

        // 如果Featcode相等，那么MeshID小的排在前面
        if (info1.MeshID != info2.MeshID)
            return info1.MeshID < info2.MeshID;

        // 如果MeshID相等，那么PoiID小的排在前面。
        return info1.PoiID < info2.PoiID;
    }

我查看了set的源码，里面分别可是实现对==  !=  <  >  <=  >=重载，所以以上的方式可以满足需求排序。

		// set TEMPLATE OPERATORS
template<class _K, class _Pr, class _A> inline
	bool operator==(const set<_K, _Pr, _A>& _X,
		const set<_K, _Pr, _A>& _Y)
	{return (_X.size() == _Y.size()
		&& equal(_X.begin(), _X.end(), _Y.begin())); }
template<class _K, class _Pr, class _A> inline
	bool operator!=(const set<_K, _Pr, _A>& _X,
		const set<_K, _Pr, _A>& _Y)
	{return (!(_X == _Y)); }
template<class _K, class _Pr, class _A> inline
	bool operator<(const set<_K, _Pr, _A>& _X,
		const set<_K, _Pr, _A>& _Y)
	{return (lexicographical_compare(_X.begin(), _X.end(),
		_Y.begin(), _Y.end())); }
template<class _K, class _Pr, class _A> inline
	bool operator>(const set<_K, _Pr, _A>& _X,
		const set<_K, _Pr, _A>& _Y)
	{return (_Y < _X); }
template<class _K, class _Pr, class _A> inline
	bool operator<=(const set<_K, _Pr, _A>& _X,
		const set<_K, _Pr, _A>& _Y)
	{return (!(_Y < _X)); }
template<class _K, class _Pr, class _A> inline
	bool operator>=(const set<_K, _Pr, _A>& _X,
		const set<_K, _Pr, _A>& _Y)
	{return (!(_X < _Y)); }

到此时，我真正见识了重载的威力，但是我对它还是半知半解，还需要继续努力，如有不正确的地方，欢迎指正。