Why is operator!= removed in C++20 for many standard library types?

by

In C++20 the way that the relational operators work was changed, notably with the introduction of the spaceship <=> operator. In particular, If you only provide operator==, then a != b is rewritten to !(a == b).

From [over.match.oper]/3.4:

The rewritten candidate set is determined as follows:

  • For the relational ([expr.rel]) operators, the rewritten candidates include all non-rewritten candidates for the expression x <=> y.
  • For the relational ([expr.rel]) and three-way comparison ([expr.spaceship]) operators, the rewritten candidates also include a synthesized candidate, with the order of the two parameters reversed, for each non-rewritten candidate for the expression y <=> x.
  • For the != operator ([expr.eq]), the rewritten candidates include all non-rewritten candidates for the expression x == y.
  • For the equality operators, the rewritten candidates also include a synthesized candidate, with the order of the two parameters reversed, for each non-rewritten candidate for the expression y == x.
  • For all other operators, the rewritten candidate set is empty.

And [over.match.oper]/9:

If a rewritten operator== candidate is selected by overload resolution for an operator @, its return type shall be cv bool, and x @ y is interpreted as:

  • if @ is != and the selected candidate is a synthesized candidate with reversed order of parameters, !(y == x),
  • otherwise, if @ is !=, !(x == y),
  • otherwise (when @ is ==), y == x,

in each case using the selected rewritten operator== candidate.

As such, an explicit overload for operator!= is no longer necessary. The removal of the operator has not changed comparison semantics.

All containers have had their operator!= removed, as far as I can tell (check e.g. the vector synopsis). The only exceptions are the container adaptors std::queue and std::stack: my guess is that it is to preserve backwards compatibility when used with third-party containers, in case the equality operators are not symmetric.

More Related Contents:

  1. Can I take the address of a function defined in standard library?
  2. Iterator invalidation rules for C++ containers
  3. What is a “span” and when should I use one?
  4. Writing your own STL Container
  5. Deleting elements from std::set while iterating
  6. std::queue iteration
  7. Forward declare a standard container?
  8. What exactly are C++ modules?
  9. C++ std::vector vs array in the real world
  10. How to use source_location in a variadic template function?
  11. C++ Filehandling: Difference between ios::app and ios::ate?
  12. Why is “!=” used with iterators instead of “
  13. Why does aggregate initialization not work anymore since C++20 if a constructor is explicitly defaulted or deleted?
  14. GCC linker can’t find standard library?
  15. Does constraint subsumption only apply to concepts?
  16. C++20 constexpr vector and string not working
  17. C++ Concept that requires a member function with an OutputIterator as parameter
  18. Why is the STL so heavily based on templates instead of inheritance?
  19. Ramifications of C++20 requiring two’s complement
  20. Why do we need to tie std::cin and std::cout?
  21. ‘auto’ as a template argument placeholder for a function parameter
  22. Comparing 3 modern c++ ways to convert integral values to strings
  23. Is C++20 ‘char8_t’ the same as our old ‘char’?
  24. What is the purpose of C++20 std::common_reference?
  25. Contiguous iterator detection
  26. How can I use a std::valarray to store/manipulate a contiguous 2D array?
  27. Range TS idioms and the mysterious auto &&
  28. Is lambdification of a concept an improvement or bad practice?
  29. How to use C++20’s likely/unlikely attribute in if-else statement
  30. if constexpr – why is discarded statement fully checked?

Leave a Comment