Re: Top 10 Worst C# Features

[Ben Bacarisse <ben.usenet@bsb.me.uk>]

Maciej Sobczak <see.my.homepage@gmail.com> writes:
<snip>
> Yes, we understand that it is possible to have incompatible
> implementations of operator== and operator!= in C++ (assuming that
> this is the language you are referring to), but we are willing to take
> this risk (and address it by other means) as it allows us to implement
> these operators more efficiently.

Do you mean that there are reasons to permit !(a == b) and a != b to
have different values in some cases?  I don't think you mean this
(because your example does not obviously address that possibility), but
I am not 100% sure.

> One possible example where this could be possible is when the
> encapsulated data has a digital signature or some other short digest
> available with the property that when two digests are different then
> the objects are surely different (and this can be determined very
> quickly), whereas when the digests are equal then more work is needed
> to determine whether the objects are equal, too. In this case, our
> operator!= can be much faster than operator== and we are willing to
> benefit from the optimization opportunity here. This could not be
> possible if one is automatically derived from the other.

I don't see why

  bool operator!=(const T &other) const noexcept
  {
    if (this.hash != other.hash)
      return true;
    return !this.long_slow_equality_test(other);
  }

is any more or less efficient than

  bool operator==(const T &other) const noexcept
  {
    if (this.hash != other.hash)
      return false;
    return this.long_slow_equality_test(other);
  }

but I may have missed the point you are trying to make.

<snip>
-- 
Ben.