c++ - c18 standard

¿Por qué los operadores std:: rel_ops:: estarán en desuso en C++ 20?

Question

De acuerdo con cppreference.com , std::rel_ops::operator!=,>,<=,>= Quedará en desuso en C ++ 20.

¿Cuál es la razón detrás?

Answer 1

¿Cuál es la razón detrás?

rel_ops fue desaprobado por el Soporte de Biblioteca para el Operador de la Nave Espacial (Comparación) . El documento no muestra ninguna motivación, pero sí aparece en el documento de la nave espacial :

Esto incluye el espacio de nombres std::rel_ops , por lo que también proponemos eliminar (o desaprobar) std::rel_ops .

Hay cuatro razones mencionadas en el documento (incluidas la corrección y el rendimiento). Pero uno grande que no se menciona en ningún documento es que std::rel_ops simplemente ... no funciona. La regla de oro es que los operadores se encuentran utilizando ADL. rel_ops no le proporciona operadores que se rel_ops encontrar en ADL, solo declara plantillas de funciones no restringidas como:

namespace std {
    namespace rel_ops {
        template< class T >
        bool operator!=( const T& lhs, const T& rhs ) 
        {
            return !(lhs == rhs);
        }
    }    
}

Entonces usando algoritmos como:

struct X { ... };
bool operator<(X const&, X const&) { ... };
std::sort(values.begin(), values.end(), std::greater<>{});

Simplemente no funciona, a menos que te asegures de:

#include <utility>
using namespace std::rel_ops;

Bastante consistentemente en todas partes como su primera inclusión para garantizar que estos operadores estén visibles en el punto de definición de cada plantilla de función que pueda llamar.

Entonces el operator<=> es estrictamente superior:

• En realidad funciona.
• Solo tienes que escribir una función ( <=> ) en lugar de dos ( == y < )
• Normalmente, tienes que escribir cero funciones ( = default )
• ¿Mencioné que realmente funciona?

Answer 2

C ++ 20 ofrece tres comparaciones entre sí, por lo que las únicas quedarán en desuso.

Answer 3

En C ++ 20, obtiene una comparación de tres vías (operador <=> ), que automáticamente "genera" comparaciones predeterminadas si se proporcionan:

struct A {
   // You only need to implement a single operator.
   std::strong_ordering operator<=>(const A&) const;
};

// Compiler generates all 6 relational operators
A to1, to2;
if (to1 == to2) { /* ... */ } // ok
if (to1 <= to2) { /* ... */ } // ok, single call to <=>

Existen múltiples ventajas de la comparación de tres vías sobre std::rel_ops , que es probablemente la razón por la que el operador std::rel_ops está en desuso. Encima de mi cabeza

• Es más versátil ya que, dependiendo del tipo de retorno del operator<=> ( std::strong_ordering , std::weak_ordering , ...), solo se generan los operadores relevantes. Consulte el encabezado <compare> para obtener más información.

• No traes un montón de sobrecargas de operadores con plantilla haciendo using namespace std::rel_ops .

• Puede pedirle al compilador que genere el operador de tres vías para usted de manera auto operator<=>(A const&) = default ( auto operator<=>(A const&) = default ): esto básicamente genera una comparación lexicográfica de clases base y miembros de datos no estáticos, además de deducirá el tipo correcto de pedido si el tipo de devolución es auto .