Mientras yo estaba tratando de aprender acerca de C++ operadores, tropecé con un extraño operador de comparación en cppreference.com,* en una tabla en la que se veía así:

¿Qué es el <=> operador en C++?

«Bueno, si estos son comunes a los operadores en C++, que es mejor aprender de ellos», pensé. Pero todos mis intentos de dilucidar este misterio fueron en vano. Incluso aquí, en el Desbordamiento de Pila no he tenido suerte en mi búsqueda.

Existe una conexión entre el <=> y C++?

Y si lo hay, ¿qué es un operador que hacer exactamente?

* En el ínterin cppreference.com actualiza la página y ahora contiene información acerca de la<=>operador.

  • Oh, por favor, hemos tenido un montón de preguntas acerca de cosas que ni siquiera votó en la norma. Tenemos un C++20 etiqueta por una razón. Este tipo de cosas mucho del tema.
  • bar< foo::operator<=> es un ejemplo de cómo podría ser el de la <-- operador.
  • A la derecha. Como C++11 es una etiqueta sobre compiladores que implementar en C++11. Y C++14 es una etiqueta sobre compiladores que implementar en C++14. Y C++17 es acerca de los compiladores que implementar en C++17. No, el C++20 es la etiqueta para cosas acerca de C++20. Y ya que esta pregunta es acerca de C++20, ahí está. La etiqueta de la wiki que estaba mal, no la propia etiqueta.
InformationsquelleAutor q-l-p | 2017-11-24

3 Comentarios

  1. 166

    Esto se llama el de tres vías comparación operador.

    De acuerdo a la P0515 de la propuesta:

    Hay una nueva de tres vías operador de comparación, <=>. La expresión a <=> b devuelve un objeto que se compara <0 si a < b, compara >0 si a > b, y compara ==0 si a y b son iguales o equivalente.

    A escribir todas las comparaciones para el tipo, acaba de escribir operator<=> que
    devuelve el correspondiente tipo de categoría:

    • Volver un _ordering si su tipo, naturalmente, apoya <, y vamos a generar de manera eficiente <, >, <=, >=, ==, y !=;
      en caso contrario, devuelve un _equality, y vamos a generar de manera eficiente
      == y !=.

    • Volver fuerte si para su tipo de a == b implica f(a) == f(b) (sustituibilidad, donde f se lee sólo la comparación salientes estado
      se puede acceder usando el nonprivate const interfaz), de lo contrario volver
      débil.

    La cppreference dice:

    Las tres vías operador de comparación de expresiones tienen la forma

    lhs <=> rhs   (1)  

    La expresión devuelve un objeto que

    • compara <0 si lhs < rhs
    • compara >0 si lhs > rhs
    • y compara ==0 si lhs y rhs son iguales o equivalente.
    • Para aquellos que están confundidos (como era mi caso) acerca de lo que «se compara <0«, «compara >0«, y «compara ==0» significa, que significan el <=> devuelve una positiva, negativa o cero, dependiendo de los argumentos. Mucho como strncmp y memcmp.
    • El primer punto-punto dice que si < está definido, entonces el compilador generará == – pero ¿cómo es eso posible? 'a' < 'b' == 1, pero ambos 'a' < 'a' y 'c' < 'a' son tanto == 0 así que no debería ser posible establecer una comparación para ser utilizado por == sin más información.
    • a pesar de que ambos 'a' < 'a' y 'c' < 'a' son falsas, 'a' < 'a' y 'a' < 'c' no lo son. EN el fuerte de pedido siguientes es verdadera: a != ba < b || b < a
    • Ah, así que puede ser definido/generada como operator==(T x, T y) { return !(x < y) && !(y < x); } y operator!=(T x, T y) { return (x < y) || (y < x); } – ah-ha! Por supuesto, esto es menos eficiente que un verdadero == como lo invoca la comparación de dos veces, pero aún limpio.
    • ¿De regreso «fuerte» y «señal débil» significa?
    • ¿Qué compares <0 decir? Se puede dar un caso de uso ejemplo?
    • esto significa que el objeto devuelve, cuando se compara < 0 evalúa a true. Es decir, si a < b luego (a <=> b) < 0 siempre es cierto.
    • Yo tenía la misma pregunta! stackoverflow.com/questions/47498486/what-does-compares-0-mean
    • Así a <=> 0 es el signo de la función?
    • no es la de regreso «fuerte» o «señal débil». Es «fuerte ordenar» y «débiles pedido». OT, pero el primero significa un «transitivo ninguno-reflectante relación», mientras que el segundo significa «transitiva reflexiva relación». Consulte «relación» en la moderna álgebra.

  2. 104

    Sobre 2017-11-11, la ISO C++ comité aprobó Herb Sutterpropuesta para la <=> «nave espacial» de tres vías operador de comparación como una de las nuevas características que se han agregado a C++20. En el documento titulado Consistente comparación Sutter, Maurer y Marrón demostrar los conceptos del nuevo diseño. Para una visión general de la propuesta, he aquí un fragmento del artículo:

    La expresión un <=> b devuelve un objeto que se compara <0 si un <
    b
    , compara >0 si a > b, y compara ==0 si a y b son
    igual o equivalente.

    Caso común: A escribir todas las comparaciones para el tipo X con el tipo Y, con memberwise semántica, acaba de escribir:

    auto X::operator<=>(const Y&) =default;

    Casos avanzados: A escribir todas las comparaciones para el tipo X con el tipo Y, sólo tiene que escribir operador<=> que toma un Y, puede utilizar
    =default para obtener memberwise semántica si se desea, y devuelve el
    adecuado tipo de categoría:

    • Devolver un _ordering si su tipo, naturalmente, apoya <, y vamos a generar de manera eficiente simétrica <, >, <=, >=, ==, y
      !=; en caso contrario, devuelve un _equality, y vamos a generar de manera eficiente
      simétrica == y !=.
    • Volver strong_ si para su tipo de a == b implica f(a) == f(b) (sustituibilidad, donde f sólo lee comparación salientes del estado que
      es accesible utilizando el público const miembros), de lo contrario volver
      weak_.

    Comparación Categorías

    Cinco comparación de las categorías se definen como std:: tipos, teniendo cada uno de los siguientes valores predefinidos:

    +--------------------------------------------------------------------+
    |                  |          Numeric  values          | Non-numeric |
    |     Category     +-----------------------------------+             |
    |                  | -1   | 0          | +1            |   values    |
    +------------------+------+------------+---------------+-------------+
    | strong_ordering  | less | equal      | greater       |             |
    | weak_ordering    | less | equivalent | greater       |             |
    | partial_ordering | less | equivalent | greater       | unordered   |
    | strong_equality  |      | equal      | nonequal      |             |
    | weak_equality    |      | equivalent | nonequivalent |             |
    +------------------+------+------------+---------------+-------------+

    Conversiones implícitas entre estos tipos se definen como sigue:

    • strong_ordering con valores {less, equal, greater} se convierte implícitamente a:
      • weak_ordering con valores {less, equivalent, greater}
      • partial_ordering con valores {less, equivalent, greater}
      • strong_equality con valores {unequal, equal, unequal}
      • weak_equality con valores {nonequivalent, equivalent, nonequivalent}
    • weak_ordering con valores {less, equivalent, greater} se convierte implícitamente a:
      • partial_ordering con valores {less, equivalent, greater}
      • weak_equality con valores {nonequivalent, equivalent, nonequivalent}
    • partial_ordering con valores {less, equivalent, greater, unordered} se convierte implícitamente a:
      • weak_equality con valores {nonequivalent, equivalent, nonequivalent, nonequivalent}
    • strong_equality con valores {equal, unequal} se convierte implícitamente a:
      • weak_equality con valores {equivalent, nonequivalent}

    De tres vías comparación

    La<=>token es introducido. La secuencia de caracteres<=>acorta a<= >, en el viejo código fuente. Por ejemplo,X<&Y::operator<=>necesidades para añadir un espacio para conservar su significado.

    La overloadable operador<=>es una función de comparación y tiene la prioridad más alta que< y menor que<<. Devuelve un tipo que puede ser comparado contra literal0pero otros tipos de retorno se permiten tales como apoyo a la expresión de las plantillas. Todos<=>operadores definidos en el lenguaje y en la biblioteca estándar de retorno de uno de los 5 mencionadosstd::comparación de tipos de categoría.

    Para tipos de idiomas, los siguientes integrado en<=>mismo tipo de comparaciones son proporcionados. Todos son constexpr, excepto donde se indique lo contrario. Estas comparaciones no puede ser invocada heterogénea utilizando escalar promociones/conversiones.

    • Parabool, integral, y los tipos de puntero,<=>devuelvestrong_ordering.
    • Para los tipos de puntero, los diferentes cv-calificaciones y derivados-de-conversiones de base se les permite invocar un homogénea integrada en<=>, y no están incorporados en la heterogéneaoperator<=>(T*, nullptr_t). Sólo comparaciones de punteros para el mismo objeto/asignación son expresiones constantes.
    • De los tipos de punto flotante,<=> devuelvepartial_ordering, y puede ser invocada heterogénea, la ampliación de los argumentos a un mayor tipo de punto flotante.
    • De las enumeraciones,<=> devuelve el mismo que el de la enumeración del tipo subyacente de la<=>.
    • Paranullptr_t,<=> devuelvestrong_orderingy siempre da elequal.
    • Para copiable matrices,T[N] <=> T[N]devuelve el mismo tipo queT‘s<=>y realiza lexicográfica elementwise comparación. No hay<=>para otras matrices.
    • Paravoidno hay<=>.

    Para entender mejor el funcionamiento interno de este operador, por favor, lea el original papel. Esto es justo lo que yo he descubierto el uso de motores de búsqueda.

    • Como si cpp no era lo suficientemente compleja ya. ¿Por qué no simplemente escribir un método de comparación…
    • La nave espacial operador es que el método de comparación. Además, Funciona y escribe (o elimina) los otros seis operadores de comparación. Voy a tomar un operador de comparación de función escrito más de seis individual boilerplates.
  3. 11

    Esta respuesta se ha convertido en irrelevante, ya que la referencia de la página web ha cambiado

    La la página web se hace referencia a estaba roto. Fue editado mucho ese día y en diferentes partes no fue en modo de sincronización. El estado cuando yo estaba mirando era:

    En la parte superior de la página enumera los actuales operadores de comparación (en C++14). No hay <=>allí.

    En la parte inferior de la página, deben tener las mismas operadores, pero cometió errores y añadido a este futuro sugerencia.

    gcc no sabe acerca de <=>sin embargo (y con -std=c++14, nunca lo será), por lo que
    piensa que significaba a <= > b. Esto se explica el mensaje de error.

    Si usted trata de la misma cosa de cinco años a partir de ahora, usted probablemente va a obtener un mejor mensaje de error, algo así como <=> not part of C++14.

    • La página web OP enlace es correcto, como es el de separar la página de enlace. Se califica la <=> operador con el (ya que C++20) de la etiqueta, que indica la versión del estándar a esperar en el. Normas de etiquetado es una convención que cppreference.com de la siguiente manera. Por supuesto, usted no tiene un compilador que llegó en una máquina del tiempo para que la apoyen para usted, pero cpprefernce dice (correctamente) qué esperar.
    • Sí, pero… No una respuesta. Usted está comentando… o algo así.
    • Tengo la intención de vincular a la misma página web como la pregunta, pero se perdió. Creo que he contestado a las partes de la pregunta con otras respuestas no. Ignoré el principal en negrita pregunta desde el otro ya había contestado eso.

Dejar respuesta

Please enter your comment!
Please enter your name here