标签: comparison-operators

我有以下运算符<应该首先按值排序,然后按另一个值排序:

    inline bool operator < (const obj& a, const obj& b) 
    {
        if(a.field1< b.field1)
            return true;
        else
            return a.field2 < b.field2;
    }

我觉得这是不正确的,如果没有对成员变量进行另一次第三次比较测试,你就不能这样做,但我找不到任何不起作用的例子.那么这真的和预期的一样吗？谢谢

编辑:我会把它编码为:

    inline bool operator < (const obj& a, const obj& b) 
    {
        if(a.field1< b.field1)
            return true;
                    else if(a.field1> b.field1)
            return false;
        else
            return a.field2 < b.field2;
    }

有什么不同吗？我问,因为我知道我的经验是正确的,但也比第一个更长

有没有办法检查两个表达式在数学上是否相等？我期望 tg(x)cos(x) == sin(x)输出True,但它输出False.有没有办法与同情进行这样的比较？另一个例子 (a+b)**2 == a**2 + 2*a*b + b**2令人惊讶地也是输出False.

我发现了一些类似的问题,但没有人提到这个问题.

从C++20开始，编译器可以通过operator ==() = default语法的方式自动生成用户类的比较运算符。但是这个运算符必须只能在类定义内部默认吗？还是也可以在类定义之后？

考虑该程序：

struct A { friend bool operator==(A,A); };
bool operator==(A,A) = default;

它被 GCC 接受，但被 Clang 拒绝，并出现错误：

error: equality comparison operator can only be defaulted in a class definition

演示： https: //gcc.godbolt.org/z/KboK7frhb

这里是哪个编译器？

例如，将运算符定义放在类定义之外对于仅将运算符放在一个翻译单元中非常有用，从而缩短了大程序的编译时间。

可能的重复:
JavaScript中的==和===之间的区别
Javascript === vs ==:我使用哪个"相等"运算符是否重要？

==和之间有什么区别===？之间!==和!==？

我试过$(document) === $(document)但发现结果是false......

有没有人有这个想法？

我想用一个接受任一参数std::greater<int>或std::less<int>作为参数的参数来创建一个函数.不过,我仍然坚持参数的语法.

这是我尝试的格式:

myFunction(int a, int b, bool *comp(int, int)) { … }
…
std::greater<int> bigger;
myFunction(2, 3, bigger);

但这不起作用,我怀疑第三个参数完全错误.它到底应该是什么？

无法转换std::greater<int>为bool* (*)(int, int)

有人可以解释我两者之间的差异.那些通常是等价的吗？也许我在这里完全错了,但我认为每个比较运算符都必然与一个"丰富的比较"方法有关.这来自文档:

运算符符号和方法名称之间的对应关系如下:

x<y电话x.__lt__(y),x<=y电话x.__le__(y),x==y电话x.__eq__(y),x!=y电话x.__ne__(y),x>y电话x.__gt__(y)和x>=y电话x.__ge__(y).

这是一个展示我困惑的例子.

Python 3.x:

dict1 = {1:1}
dict2 = {2:2}

>>> dict1 < dict2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'dict' and 'dict'
>>> dict1.__lt__(dict2)
NotImplemented

Python 2.x:

dict1 = {1:1}
dict2 = {2:2}

>>> dict1 < dict2
True
>>> dict1.__lt__(dict2) …

在Python3中,functools.total_ordering装饰器允许只重载__lt__并__eq__获得所有6个比较运算符.

我不明白为什么一个人必须写两个运算符就足够了,即__le__或者__ge__,并且所有其他运算符都会相应地定义:

a < b   <=>   not (b <= a)
a > b   <=>   not (a <= b)
a == b   <=>   (a <= b) and (b <= a)
a != b   <=>   (a <= b) xor (b <= a)

那是因为xor运算符本身不存在吗？

例如

int f(int a) {
   ...
   return a > 10;
}

被认为是可以接受的(不合法,我的意思是它是"好的代码"),或者它应该总是在有条件的,像这样

int f(int a) {
   ...
   if (a > 10)
      return 1;
   else
      return 0;
}

Python是否定义了"NaN> 0"的值？在我的Python解释器中,我得到:

>>> float('nan') > 0
False

但这有保证吗？

如果我理解正确,IEEE 754标准将任何涉及NaN的比较赋予False.但是,我在Python文档中找不到任何表明遵循此标准的内容.我甚至明白1/0,在IEEE 754下应该给无限,但是Python引发了异常(ZeroDivisionError),所以Python并没有完全遵循IEEE 754.

那么,是float('nan') > 0在Python 中完全定义的结果吗？我需要知道在所有平台上以及所有版本的Python(包括旧版本)是否相同.