Question

给出

struct node{
    int row;
    int cols;
    int cost;
}

仅当行和列相等时，我才需要按路径成本排序的节点集合a == b。我的问题是如何使运算符超载，以便该集合可以保存不同的节点但路径成本相同？而且如果a == b节省了成本，那就省个

Answer 1

如果a == b保存成本最低的一个

使用 std :: set 不能拥有它：a==b意味着a<b和b<a为假，因此当 a 和 b 具有相同的 row 和 cols operator<必须返回false，并且不考虑 cost

要获得预期的行为，您必须实现自己的 set ，而不仅仅是使用operator<进行排序/插入。

按路径成本排序

我想你的意思是按成本订购

使用 std :: set 和operator<，我们可以考虑拥有：

  bool operator <(const node & rhs) const {
    // to satisfy a==b only if row and cols are equal
    if ((row == rhs.row) && (cols == rhs.cols))
      return false;

    return (cost < rhs.cost) ||
      ((cost == rhs.cost) &&
       ((row < rhs.row) || ((row == rhs.row) && (cols < rhs.cols))));
  }

但这是错误的，例如

#include <set>
#include <iostream>

struct node{
  int row;
  int cols;
  int cost;

  bool operator <(const node & rhs) const {
    // to satisfy a==b only if row and cols are equal
    if ((row == rhs.row) && (cols == rhs.cols))
      return false;

    return (cost < rhs.cost) ||
      ((cost == rhs.cost) &&
       ((row < rhs.row) || ((row == rhs.row) && (cols < rhs.cols))));
  }
};

int main()
{
  const node a[] = { {3,2,3} , {3,2,2}, {4,3,2}, {7,2,3}, {3, 2, 9} };
  std::set<node> s;

  for (size_t i = 0; i != sizeof(a)/sizeof(*a); ++i)
    s.insert(a[i]);

  for (auto x : s)
    std::cout << '(' << x.row << ' ' << x.cols << ' ' << x.cost << ')' << std::endl;

  return 0;
}

编译和执行：

pi@raspberrypi:/tmp $ g++ -pedantic -Wextra -Wall s.cc
pi@raspberrypi:/tmp $ ./a.out
(4 3 2)
(3 2 3)
(7 2 3)
(3 2 9)

集包含3 2 3和3 2 9，即使它们必须被视为相等。

operator<是错误的，因为将3 2 3和3 2 9与其他值进行比较时不一致：7 2 3小于3 2 9，但是不少于3 2 3

a == b仅在row和cols相等的情况下

暗示排序必须仅考虑 row 和 cols ，但必须 cost 不使用

例如

#include <set>
#include <iostream>

struct node{
  int row;
  int cols;
  int cost;

  bool operator <(const node & rhs) const {
    return (row < rhs.row) || ((row == rhs.row) && (cols < rhs.cols));
  }
};

int main()
{
  const node a[] = { {3,2,3} , {3,2,2}, {4,3,2}, {7,2,3}, {3, 2, 9} };
  std::set<node> s;

  for (size_t i = 0; i != sizeof(a)/sizeof(*a); ++i)
    s.insert(a[i]);

  for (auto x : s)
    std::cout << '(' << x.row << ' ' << x.cols << ' ' << x.cost << ')' << std::endl;

  return 0;
}

编译和执行：

pi@raspberrypi:/tmp $ g++ -pedantic -Wextra -Wall s.cc
pi@raspberrypi:/tmp $ ./a.out
(3 2 3)
(4 3 2)
(7 2 3)
pi@raspberrypi:/tmp $

尊重期望的平等性，但与成本

无关

从C ++ 11开始（感谢@PaulMcKenzie的评论）：

  bool operator <(const node & rhs) const {
    return std::tie(row, cols) < std::tie(rhs.row, rhs.col);
  }

在要考虑很多字段的情况下非常实用

重载集<运算符

1 个答案: