通过“元组”实现比较运算符和“领带”，是个好主意吗？

Question

^{（注意：tuple 和 tie 可以取自 Boost 或 C++11。）}
当编写只有两个元素的小型结构时，我有时倾向于选择 std::pair，因为所有重要的事情都已经针对该数据类型完成，例如严格的运算符operator -弱排序。
但缺点是变量名几乎无用。即使我自己创建了 typedef，两天后我也不会记得 first 和 second 到底是什么，特别是如果它们都是的话属于同一类型。对于两个以上的成员来说，情况会变得更糟，因为嵌套对非常糟糕。
另一种选择是元组，来自 Boost 或 C++11，但这看起来并没有更好、更清晰。所以我回去自己编写结构，包括任何需要的比较运算符。
特别是由于 operator< 可能相当麻烦，我想通过仅依靠为 tuple 定义的操作来避免整个混乱：

operator< 的示例code>，例如对于严格弱排序：（

bool operator<(MyStruct const& lhs, MyStruct const& rhs){
  return std::tie(lhs.one_member, lhs.another, lhs.yet_more) <
         std::tie(rhs.one_member, rhs.another, rhs.yet_more);
}

tie 从传递的参数中创建 T& 引用的 tuple。）

---

编辑： @DeadMG 从 tuple 私有继承的建议并不是一个坏建议，但它有很多缺点：

• 如果运算符是独立的（可能是朋友），我需要
• 通过强制转换 公开继承，我的函数/运算符（特别是operator=）可以很容易地绕过
• 使用tie解决方案，我可以省略某些与排序无关的成员

。我需要解决此实现中的任何缺点 考虑？

Answer 1

这肯定会让编写正确的运算符比自己编写更容易。我想说，只有当分析显示比较操作是应用程序中耗时的部分时，才考虑使用不同的方法。否则，维护的便利性应该超过任何可能的性能问题。

Answer 2

我遇到了同样的问题，我的解决方案使用 c++11 可变参数模板。代码如下：

.h 部分：

/***
 * Generic lexicographical less than comparator written with variadic templates
 * Usage:
 *   pass a list of arguments with the same type pair-wise, for intance
 *   lexiLessthan(3, 4, true, false, "hello", "world");
 */
bool lexiLessthan();

template<typename T, typename... Args>
bool lexiLessthan(const T &first, const T &second, Args... rest)
{
  if (first != second)
  {
    return first < second;
  }
  else
  {
    return lexiLessthan(rest...);
  }
}

以及不带参数的基本情况的 .cpp：

bool lexiLessthan()
{
  return false;
}

现在您的示例变为：

return lexiLessthan(
    lhs.one_member, rhs.one_member, 
    lhs.another, rhs.another, 
    lhs.yet_more, rhs.yet_more
);

Answer 3

在我看来，您仍然没有解决与 std::tuple 解决的相同问题 - 也就是说，您必须知道每个成员变量的数量和名称，您正在复制它函数中两次。您可以选择私有继承。

struct somestruct : private std::tuple<...> {
    T& GetSomeVariable() { ... }
    // etc
};

这种方法一开始就有点混乱，但是您只需将变量和名称维护在一个位置，而不是在您希望重载的每个运算符的每个位置维护。

Answer 4

如果您计划使用多个运算符重载或元组中的多个方法，我建议将元组设为类的成员或从元组派生。否则，你所做的工作会更多。在两者之间做出决定时，需要回答的一个重要问题是：您希望您的类成为元组吗？如果不是，我建议包含一个元组并通过使用委托来限制接口。

您可以创建访问器来“重命名”元组的成员。