使用结构键的std :: map的高效比较器

Question

我有一个以下类型的结构，我计划将它用作映射中的键。因此，我写下如下的比较器。我想知道是否有更优雅而有效的方式来做到这一点。 可能会使用std :: pair或其他东西。

struct T 
{ 
    int a, b, c, d; 

    bool operator< (const T& r) { 
    if (a < r.a) 
     return true 
    else if (a == r.a) 
     if (b < r.b) 
      return true; 
     else if (b == r.b) 
      if (c < r.c) 
       return true; 
      else if (c == r.c) 
       if (d < r.d) 
        return true; 
    return false; 
    } 


} 

Answer 1

你可以使用C++ 11吗？如果是这样的：

struct T { 
    int a, b, c, d; 

    bool operator<(const T& rhs) const { 
     return tied() < rhs.tied(); 
    } 

private: 
    std::tuple<int, int, int, int> tied() const { 
     return std::make_tuple(a, b, c, d); 
    } 
}; 

另外，我宁愿return荷兰国际集团在每一个可能的机会，避免了容易出错的尴尬嵌套方式：

bool operator<(const T& rhs) const { 
    if (a != rhs.a) return a < rhs.a; 
    if (b != rhs.b) return b < rhs.b; 
    if (c != rhs.c) return c < rhs.c; 
    return d < rhs.d; 
} 

Answer 2

可以使用...

bool operator<(const T& r) 
{ 
    return a < r.a || 
      a == r.a && (b < r.b || 
         b == r.b && (c < r.c || 
            c == r.c && d < r.d)); 
} 

或...

return a != r.a ? a < r.a : 
      b != r.b ? b < r.b : 
      c != r.c ? c < r.c : 
         d < r.d; 

---

你说你不使用C++ 11，和巴里有一个元组方式的一个很好的例证，但是为了将来的参考和其他有关各方，有一点可重用的支持代码...

bool less_by_pairs() 
{ 
    return false; 
} 

template <typename T, typename U, typename ...Args> 
bool less_by_pairs(const T& v1, const U& v2, Args... args) 
{ 
    return v1 != v2 ? v1 < v2 : less_by_pairs(args...); 
} 

...你可以更容易地实现这样的服务商...

bool operator<(const T& r) 
{ 
    return less_by_pairs(a, r.a, b, r.b, c, r.c, d, r.d); 
} 

你可以做类似的向会员提供比较列表的东西，但是对于符号实际上是一个有点冗长反正。

Answer 3

您可以使用其他字段来存储密钥。可以通过一个公式来生成这个键值，即作为输入(a,b,c,d)

像这样：

void hash() 
{ 
    key = (a^b^c^d); 
} 

至于结果，你只需要比较这关键的知道，如果内容是相同的。