C++ 操作员<；严格弱序

如何定义

运算符
if（a1

这按a1最显著，a3最不显著的顺序排列元素

这可以无限期地继续，例如，您也可以将其应用于T的向量，迭代a[i]
while（i你可以简单地使用三个元素向量，即使你不能使用boost版本，也会有操作符，你应该能够修改代码。我从std:：pair中修改了这个，我想3元组也会类似

return (_Left.first < _Right.first ||
        !(_Right.first < _Left.first) && _Left.second < _Right.second);

返回（_Left.first<_Right.first||
！（_Right.first<_Left.first）和&&u Left.second<_Right.second）；

编辑：正如一些人指出的，如果您从标准库中窃取代码用于代码中，您应该重命名前面带有下划线的内容，因为这些名称是保留的。
基本流程应该是这样的：如果第k个元素不同，则返回较小的元素，否则转到下一个元素下面假设您没有boost元组，否则您将使用
get（tuple）
而不会出现问题

if (lhs.first != rhs.first)
    return lhs.first < rhs.first;                
if (lhs.second != rhs.second)
    return lhs.second< rhs.second;
return lhs.third < rhs.third;

if（lhs.first！=rhs.first）
返回lhs.first
严格弱排序
这是一个数学术语，用于定义两个对象之间的关系。

其定义是：

如果f（x，y）和f（y，x）都为false，那么两个对象x和y是等价的。请注意，一个对象总是（通过不可伸缩性不变量）等价于它自己

在C++方面，这意味着如果你有两个给定类型的对象，当与操作符
相比时，你应该返回以下值……一个非常古老的问题的新答案，但是现有的答案错过了C++ 11……/P>的简单解。
C++11解决方案
C++11及以后版本提供了，您可以使用它来存储数据。
元组
s有一个匹配项，该匹配项最初比较最左边的元素，然后沿着元组工作，直到结果清晰为止。这适合于提供预期的，例如和

如果您在某些其他变量中有数据（例如
结构中的字段
），您甚至可以使用创建一个引用元组，然后将其与另一个这样的元组进行比较。这使得编写
运算符变得很容易。这假设问题在于元组内的排序，而不是我假设的元组间的排序。好的，编辑的代码比较元组间的排序，而不是元组内的排序。我猜！是的，添加了一条注释，但没有得到通过。原始代码真的是d'oh。我可以说它显示了原理，但实际上没有做任何有用的事情，但是……如果你有向量示例中的迭代器，只需使用
std:：lexographical\u compare
。这是-的实现，是许多可能的严格限制之一n元组上的弱排序。请澄清：您所说的是定义运算符。当然，您不应该实际使用该代码（至少在不首先重命名变量的情况下）。在标准库之外，前导下划线是不好的。公正的评论，我只是不假思索地粘贴了它。这是反对剪切和粘贴代码的一个很好的理由！+1。这样做的好处是只需要较少的可比行为，而不是额外要求在许多其他答案中隐含的平等可比概念。并非所有的事情都需要前面的下划线总是保留的。
\u Leadingcapitals
总是保留的，就像在本例中一样。任何包含
双下划线的标识符都是保留的。但是，
\u leadinglowercase
只保留在全局范围内（不过我认为它也不值得在其他地方使用）。这是我读过的关于严格弱序的最好解释。我喜欢你通过详尽地解释所有案例而说得非常清楚。具体地说，帮助我理解如何建立严格弱序的是如何通过
a
和
b
永远不小于另一个来确定等价性。这正是存在缺陷的地方我有更多关于如何使用一个成员
tie（）
函数来支持中多个运算符的简明和一致版本的详细信息，但是要总结
auto my_Struct:：tie（）const{return std:：tie（a_u，b_u，c_u）}
然后例如
bool运算符
if (a1 != b1)
  return a1 < b1;

if (a2 != b2)
  return a2 < b2;

...

return (_Left.first < _Right.first ||
        !(_Right.first < _Left.first) && _Left.second < _Right.second);

if (lhs.first != rhs.first)
    return lhs.first < rhs.first;                
if (lhs.second != rhs.second)
    return lhs.second< rhs.second;
return lhs.third < rhs.third;

X    a;
X    b;

Condition:                  Test:     Result
a is equivalent to b:       a < b     false
a is equivalent to b        b < a     false

a is less than b            a < b     true
a is less than b            b < a     false

b is less than a            a < b     false
b is less than a            b < a     true

struct S
{
     ThingA   a;
     ThingB   b;
};
bool operator<(S const& lhs, S const& rhs)
{
    return std::tie(lhs.a, lhs.b) < std::tie(rhs.a, rhs.b);
}

bool operator==(S const& lhs, S const& rhs)
{
    return std::tie(lhs.a, lhs.b) == std::tie(rhs.a, rhs.b);
}

struct My_Struct
{
    int a_;
    double b_;
    std::string c_;
};

bool operator<(const My_Struct& lhs, const My_Struct& rhs)
{
    return std::tie(lhs.a_, lhs.b_, lhs.c_) < std::tie(rhs.a_, rhs.b_, rhs.c_);
}