Início / coding / Perguntas / 77977022
Accepted
Piotr Siupa
Asked: 2024-02-11 22:04:32 +0800 CST

Como faço para usar o operador nave espacial em uma instrução switch

  • 772

O novo <=>operador torna a escrita de código mais conveniente e pode economizar algum desempenho se o algoritmo de comparação não for trivial, porque não precisa ser repetido duas vezes para obter a ordem completa.

Ou pelo menos pensei assim quando soube disso. Porém, quando tento usar na prática, em um switchdepoimento, não funciona.

Este código não compila:

#include <iostream>

void compare_values(int x, int y)
{
    switch (x <=> y)
    {
    case std::strong_ordering::less:
        std::cout << "is less\n";
        break;
    case std::strong_ordering::greater:
        std::cout << "is greater\n";
        break;
    case std::strong_ordering::equal:
        std::cout << "is equal\n";
        break;
    }
}

O compilador mostra um erro sugerindo que o valor retornado por <=>não pode ser usado em a switch:

<source>: In function 'void compare_values(int, int)':
<source>:5:15: error: switch quantity not an integer
    5 |     switch (x <=> y)
      |             ~~^~~~~
Compiler returned: 1

( exemplo ao vivo )

Eu acho que usar o operador de nave espacial no switch é um caso de uso bastante básico, óbvio e comum, então provavelmente existe algum truque para fazê-lo funcionar. Eu não consigo entender, no entanto.

Como posso corrigir esse código?

c++

2 respostas

  1. Best Answer

    O problema é que o operador nave espacial (formalmente conhecido como comparação de três vias ) não retorna um tipo ingeral e, portanto, não pode ser usado em uma switch-caseinstrução.

    Neste caso de comparação de tipos como ints, o operador nave espacial retorna a std::strong_ordering.

    (Uma observação lateral: como você pode ver na documentação, há casos em que o operador da nave espacial retorna a, std::partial_orderingmas este também não é um tipo integral).

    Você pode usá-lo em uma if-elsedeclaração.

    Se preferir usar a switch-case, você pode usar um utilitário trivial que converte the std::strong_orderingem um tipo integral com alguns valores predefinidos.
    Retornar -1/0/1 neste caso será bastante natural:

    #include <iostream>

constexpr int strong_ordering_to_int(std::strong_ordering o)
{
    if (o == std::strong_ordering::less)    return -1;
    if (o == std::strong_ordering::greater) return 1;
    return 0;
}

void compare_values(int x, int y)
{
    switch (strong_ordering_to_int(x <=> y))
    {
    case -1:
        std::cout << "is less\n";
        break;
    case 1:
        std::cout << "is greater\n";
        break;
    case 0:
        std::cout << "is equal\n";
        break;
    }
}

int main()
{
    compare_values(2, 3);
    compare_values(3, 2);
    compare_values(3, 3);
}

    Saída:

    is less
is greater
is equal

    Demonstração ao vivo

    • 4

  2. Os compiladores fazem um péssimo trabalho ao otimizar os métodos if (gcc/clang/MSVC). A melhor maneira de obter um bom codegen é brincar com as 3 grandes implementações usando um membro de valor char subjacente. Pode-se facilmente adicionar static_asserts com os valores strong_ordering/weak_ordering para garantir isso. O seguinte irá otimizar para, na pior das hipóteses, uma cópia. A única desvantagem é que se perde a nomenclatura explícita, mas é possível adicionar ainda uma classe enum/enum como valor de retorno.

    #include <compare>
#include <bit>

constexpr signed char to_integral( std::strong_ordering x ) {
    return std::bit_cast<signed char>( x );
}
constexpr signed char to_integral( std::weak_ordering x ) {
    return std::bit_cast<signed char>( x );
}
    • 0

relate perguntas