相关疑难解决方法(0)

请看以下示例:

>>> class C(object):
...     def __init__(self, p):
...         self.p = p
...     def __eq__(self, o):
...         return True
... 
>>> C(1) is C(2)
False
>>> C(1) == C(2)
True
>>> C(1) != C(2)
True # <- Why?!?

所以现在这两个对象是相同的,并且不是同等的.我虽然这两个行动是对立的？!

可能重复:
为什么我们必须在C#中定义==和!=？

为什么重载+ =只能通过重载+,但==和!=分别重载？
它似乎应该倒置.
+ =重载几乎总是可以写得更有效,因为没有必要为新对象分配内存.但是我不能发明一个例子,其中运算符==和!=应该是不同的,除了反转结果Equals().

我有一段代码实现了==重载.我不得不在某个否定的地方使用它.但是!(A == B)对于读者而言,写作似乎并不清楚.所以我实现了这个双重重载.这样做有什么缺点吗？效率明智吗？:

struct Foo{
  bool operator==(const Foo& other) const{
      .... //Something that sometimes produces "return false"
      return true;
  }
  bool operator!=(const Foo& other) const{
      return !(*this == other);
  }
}

额外:为什么编译器没有!=使用否定的默认实现==？

假设您正在编写原始C#Object类,并且您需要以下功能:

1. object1 == object2 将比较引用,除非重写此运算符
2. object1 != object2 将始终返回对象的ACTUAL的反转 object1 == object2

因此,例如,如果我有一个使用ear length作为其equals方法的Bunny类(派生自Object),那么Object如果bunnies具有不同的ear长度,则notequals方法(继承自)应该返回true.

我看到的问题是,如果我写我的Object课:

public partial class Object {
    public virtual bool Equals(Object o2) {
       return (this === o2);
    }

    public bool NotEquals(Object o2) {
       return !this.Equals(o2);
    }
}

那么看起来这个定义会将ObjectNotEquals 绑定到's Equals,而不是实际派生类的equals.

有没有什么方法可以在不以任何方式修改C#本身的情况下工作？我并不在乎C#中的可能性,但我关心是否有一些OOP原则告诉我我不应该期待这种事情能够发挥作用.

此外,我不确定这是否是这个问题的基础,但是想法是NotEquals也是虚拟的,所以它也可以被希望它们o1 != o2与之不同的派生类所覆盖!(o1 == o2).这个问题的灵感来自最近的讨论.