0

当我意识到不可能使用一个集合并且我必须创建一个新集合并具有自定义排序功能来使用它时，我正在尝试使用一个集合。我在网上研究并尝试实现自己的自定义排序功能，但不知道如何去做

这是我的课

class Point2D
{
 public:

           int getX() const;
           int getY() const;

           void setX(int);
           void setY(int);


          bool operator < ( const Point2D& x2) const
          {
            if ( x != x2.x)
            {
            return x < x2.x;
            }
            if ( y != x2.y)
            {
              return y < x2.y;
            }
          };

 protected:

             int x;
             int y;


};

目前它是根据 x 值后跟 y 值排序的，我想根据

y 值后跟 x 值

因此我实现了这个自定义排序

bool p2d_sortby_y(Point2D& ptd1 , Point2D& ptd2) //custom sort function
{
    if ( ptd1.getY() != ptd2.getY())
    {
        return ptd1.getY() < ptd2.getY();
    }
  if ( ptd1.getX() != ptd2.getX() )
    {
        return ptd1.getX() < ptd2.getX();
    }

    return false;
}

这是我如何尝试使用集合的示例代码，

#include <iostream>
#include <string>
#include <fstream>
#include <set>
#include <cmath>
using namespace std;
class Point2D
{
 public:

           int getX() const;
           int getY() const;

           void setX(int);
           void setY(int);


          bool operator < ( const Point2D& x2) const
          {
            if ( x != x2.x)
            {
            return x < x2.x;
            }
            if ( y != x2.y)
            {
              return y < x2.y;
            }
          };

 protected:

             int x;
             int y;


};

bool p2d_sortby_y(Point2D& ptd1 , Point2D& ptd2) //custom sort function
{
    if ( ptd1.getY() != ptd2.getY())
    {
        return ptd1.getY() < ptd2.getY();
    }
  if ( ptd1.getX() != ptd2.getX() )
    {
        return ptd1.getX() < ptd2.getX();
    }

    return false;
}



int main()
{
    set<Point2D> p2d_set;

    Point2D p2d;

    p2d.setX(1);
    p2d.setY(3);

    p2d_set.insert(p2d);

    p2d.setX(3);
    p2d.setY(2);

    p2d_set.insert(p2d);

    set<Point2D>::iterator p2 = p2d_set.begin();

   while ( p2 != p2d_set.end() )
   { 
     cout<<p2->getX()
         <<" "
         <<p2->getY()
         <<endl;
     p2++;
   }


   set<Point2D,p2d_sortby_y> p2d_set2 = p2d_set; // i am unsure of how to implement the custom sort function here





}



int Point2D::getX() const
{
   return x;
}

int Point2D::getY() const
{
   return y;
}
void Point2D::setX(int x1)
{
   x = x1;
}

void Point2D::setY(int y1)
{
 y = y1;  ;
}

谁能帮帮我谢谢？？

4

4 回答 4

5

这将是一种更简单的方法：

#include <tuple>

struct SortByYX
{
  bool operator ()(const Point2D& lhs, const Point2D& rhs) const
  {
    return std::tie(lhs.y, lhs.x) < std::tie(rhs.y, rhs.x);
  }
};

然后

set<Point2D, SortByYX> p2d_set2(p2d_set.begin(), p2d_set.end());

编辑：std::tie需要 C++11 支持，但如果你没有它，你可以使用std::tr1::tiefrom <tr1/tuple>，或者boost::tie如果你没有 TR1。

于 2013-11-14T13:45:35.373 回答
0

在set<Point2D, p2d_sortby_y>第二个参数p2d_sortby_y中没有命名类型。

struct point_odered_by_y
{
    bool operator()(const Point2D& ptd1, const Point2D& ptd2) const
    {
        /* .. */
    }
};



typedef std::set<Point2D, point_odered_by_y> pointset;
pointset s(begin(p2d_set), end(p2d_set));
于 2013-11-14T13:45:51.307 回答
0

通常最好定义一个仿函数类来指定排序，而不是一个函数；这样，您可以将其指定为模板参数：

struct p2d_sortby_y {
    bool operator()(Point2D x, Point2D y) {return whatever;}
};

这必须通过值或const引用（而不是非const引用，就像你的那样）来获取它的参数，才能用于常量集成员。

您不能直接从不同类型的集合初始化新集合，但可以从其范围初始化它：

set<Point2D,p2d_sortby_y> p2d_set2(p2d_set.begin(), p2d_set.end());
于 2013-11-14T13:46:07.277 回答
0

您的两组具有不同的类型（比较功能是类型定义的一部分）。

由于std::set不为不同的比较函数提供构造函数或赋值运算符，因此您必须使用迭代器对初始化新集合到您的第一个集合或std::copy元素上。

那是：

set<Point2D,p2d_sortby_y> p2d_set2 { std::begin(p2d_set), std::end(p2d_set) };

或者

set<Point2D,p2d_sortby_y> p2d_set2;
std::copy(std::begin(p2d_set), std::end(p2d_set), std::inserter(p2d_set2));
于 2013-11-14T13:46:28.687 回答