我应该如何比较指针对（用于排序谓词）

Question

我有一个 STL 容器，里面装满了以下数十亿个对象

pair<SomeClass*, SomeClass*>

我需要以下形式的一些功能

/*returns items sorted biggest first */

bool sortPredicate (pair<SomeClass*, SomeClass*>two,  pair<SomeClass*, SomeClass*> one)
{
  return ???;
}

有什么技巧可以用来快速比较指针对吗？

编辑 1：澄清

最后我只想对指针对列表进行排序，使所有重复项彼此相邻。假设 SomeClass 中没有明确的方法可用于此目的——我只有指针对，我想找到所有相同的对（并行）。我认为排序可以解决问题，但如果您能想到更好的并行方法，请告诉我。

编辑 2：澄清

修复了我的代码（排序谓词的参数错误——它们应该是对的）。

Answer 1

C++ 的一个怪癖是，相同类型的任意指针不能（必然）与 std::less 可比。

不幸的是，std::pair 的operator< 是根据组件上的operator< 定义的，而不是std::less。

因此，假设您希望两对落在相同的排序位置当且仅当它们指向相同的两个对象时，您需要：

// "less than"
template<typename T>
bool lt(const T &lhs, const T &rhs) {
    return std::less<T>()(lhs, rhs);
}

typedef std::pair<SomeClass*, SomeClass*> mypair;

bool sortPredicate(const mypair &lhs, const mypair &rhs) {
    return lt(lhs.first, rhs.first) 
        || (!lt(rhs.first, lhs.first) && lt(lhs.second, rhs.second));
 }

在您可以命名的几乎任何系统上，它都应该编译为与return lhs < rhs; 相同的代码，但这在形式上是不正确的。如果指针的引用都是同一对象的子对象（例如，如果您有一个巨大的数组并且所有对都指向该数组的元素），那么 operator< 对于指针来说是可以的，因此对于 @987654329 来说是可以的@。

如果您希望配对落在相同的排序位置当且仅当它们指向的对象排序相同，那么您需要添加额外的取消引用：

bool sortPredicate(const mypair &lhs, const mypair &rhs) {
    return lt(*lhs.first, *rhs.first) 
        || (!lt(*rhs.first, *lhs.first) && lt(*lhs.second, *rhs.second));
 }

如果允许的话，也许您还会添加对空指针的检查。当然如果你知道 SomeClass 确实是类类型，而不是指针类型，那么就不需要在上面的版本中使用std::less，只需为 SomeClass 定义operator< 并：

inline bool lessptr(const SomeClass *lhs, const SomeClass *rhs) {
    if (lhs == 0) return rhs != 0;
    if (rhs == 0) return false;
    return *lhs < *rhs;
}

bool sortPredicate(const mypair &lhs, const mypair &rhs) {
    return lessptr(lhs.first, rhs.first) 
        || (!lessptr(rhs.first, lhs.first) && lessptr(lhs.second, rhs.second));
 }

您可能会也可能无法优化这一点，因为在第一次和第二次调用lessptr 时都会执行一些重复的空检查。如果你那么在意，看看编译器是怎么处理它的。

Answer 2

假设你的类有比较运算符：

bool sortPredicate (SomeClass *two,  SomeClass *one)
{
  return *two > *one;
}

如果只想比较指针地址，使用std::greater<T>：

sort(container.begin(), container.end(), std::greater<SomeClass *>());

编辑：好的，我真的不知道你现在想做什么，你最近的编辑。如果您只想查找重复项，为什么不直接使用默认排序？

Answer 3

如果我理解正确，您的谓词应具有以下签名

bool sortPredicate(pair<SomeClass*, SomeClass*>& lhs, pair<SomeClass*, SomeClass*>& rhs);

我对 Your 类以及它是否有任何自然顺序一无所知，因此很难猜测您想如何对其进行排序。在评论中您写道，最大的项目应该是第一位的。我假设该类有

bool sortPredicate(pair<SomeClass*, SomeClass*>& lhs, pair<SomeClass*, SomeClass*>& rhs)
{
    if(!(*(lhs.first) < *(rhs.first) || *(rhs.first) < *(lhs.first))) // If there is == operator use it.
    {
        return *(rhs.second) < *(lhs.second);
    }
    else
    {
        return *(rhs.first) < *(lhs.first);
    }

}

编辑：好的谢谢澄清。这个怎么样？

bool sortPredicate(pair<SomeClass*, SomeClass*>& lhs, pair<SomeClass*, SomeClass*>& rhs)
{
    if(lhs.first == rhs.first)
    {
        return rhs.second < lhs.second;
    }
    else
    {
        return rhs.first < lhs.first;
    }
}

Answer 4

你应该在你的pair类上定义一个operator<。我假设您的配对持有item1 和item2。所以：

template <class T>
class pair{
private:
  T item1;
  T item2
public:
  // [...] other stuff goes here
  // here the comparing
  bool operator<(pair p){
    return (item1 < p.item1 || (item1 == p.item1 && item2 < p.item2));
  }
};

此解决方案假定项目已定义 < 和 == 运算符。

我想我没有满足您的确切要求，但我建议在您的 pair 类中重载 <、> 和 == 运算符。