严格的弱序混淆

Question

我对严格的弱排序以及在定义运算符时如何使用它感到困惑

struct Plane
{
    std::string name;

    int xrudder;
    int yrudder;

    int wingwidgets;

    bool hasLegacyEngine;
};


struct Airport
{
    bool securityCheck;
    unsigned __int64 capacity;

    std::vector<Plane> planes;
};

我想创建一个std::set 的机场。我需要定义 operator

struct cmpless
{
bool operator()(const Airport& left, const Airport& right)
    {
        //?
    }
}; 

std::set<Airport, cmpless> airportSet;

一个机场“小于”另一个机场是没有意义的。只有当机场的统计数据相等时才有意义。

我如何确定我对 operatoroperator<？

如果可能的话，一个带有解释的例子会很棒！

Answer 1

在musingstudio blog 上找到了一个不错的解决方案，并认为我在这里分享它以供下一个需要的人使用（即使 Dietmar 可能正确地认为地图不合适）：

bool operator <(const T& rhs) const
{
  if (a < rhs.a)
    return true;
  else if (rhs.a < a)
    return false;

  if (b < rhs.b)
    return true;
  else if (rhs.b < b)
    return false;

  // repeat for all child elements c, d, e etc
  return false;
}

Answer 2

如果一个Airport 出现在另一个Airport 之前“没有意义”，那么使用std::set<Airport> 也没有意义。此容器利用订单金额元素在O(log(n)) 操作中定位对象（其中n 是容器的大小）。如果您只能通过身份识别对象，那么您可以实现的最佳复杂度是O(n)。您可以使用std::find() 或std::find_if() 和序列容器之一的组合，例如std::vector<Airport> 或std::deque<Airport>。

由于您不需要根据operator<() 定义顺序，因此将Airports 放入某种顺序可能是合理的，以便将它们定位在std::set<Airport> 中，由使用与std::less<Airport> 不同的比较函数对象。不过，您当前在 Airport 对象中拥有的属性看起来并不像合适的键。事实上，它们看起来都好像是可变的，也就是说，你可能不想要std::set<Airport>，因为你不能修改std::set<T> 中的元素（好吧，至少，你不应该；是的，我知道你可以用mutable 来耍花招，但这势必会破坏元素的顺序）。

基于此，我建议使用std::map<std:string, Airport>：std::string 用于识别机场，例如，使用机场代码，如纽约约翰肯尼迪机场的"JFK" 或"LHR" 伦敦希思罗机场。方便的是，已经在字符串上定义了严格的弱顺序。

也就是说，要在一组对象 O 上定义一个 strict weak order，您需要一个二元关系 r(x, y)，使得以下条件适用于元素 x、y 和 z来自O：

• 不自反：r(x, x) == false
• 不对称：r(x, y) == true 暗示r(y, x) == false
• 传递：r(x, y) == true 和 r(y, z) == true 暗示 r(x, z) == true
• 不可比性：r(x, y) == false 和 r(y, x) == false 和 r(y, z) == false 和 r(z, y) == false 暗示 r(x, z) == false 和 r(z, x) == false

前三个应该足够简单。最后一个起初有点奇怪，但实际上也没有那么难：基本思想是关系并不完全对元素进行排序，而是将它们分组到等价的类中。如果您认为r 的关系“小于”它只是说如果x 既不小于y 也不小于y 小于x，那么x 和y 是相等的。无与伦比的元素只是等价的。

标准容器使用严格的弱顺序，但例如 std::set<T> 和 std::map<K, V> 只保留一个版本的等效键。很好，这已经足够了，但通常只使用一个严格的弱顺序的总顺序更简单，其中每对元素 x 和 y 要么是 r(x, y) == true 要么 r(y, x) == true （但是，由于不对称不是两者都有）。

Answer 3

如果每个成员都定义了<，您可以执行类似于字典顺序的操作：

   struct cmpless
    {
    bool operator()(const Airport& left, const Airport& right)
        {
            return
              left.securityCheck < right.securityCheck
              || ((left.securityCheck == right.securityCheck
                   && left.capacity < right.capacity)
                  || (left.capacity == right.capacity
                      && left.planes < right.planes));
        }
    };