Início / coding / Perguntas / 78584699
Accepted
alfC
Asked: 2024-06-06 13:53:32 +0800 CST

Como o `if constexpr` pode ser compatível com SFINAE?

  • 772

Eu tenho um código usando SFINAE "clássico".

template<class M> auto power(M const& elem) -> decltype(std::norm(elem)) { return std::norm(elem); }

template<class M, class = std::enable_if_t<(M::rank::value >= 1)>>
auto power(M const& array) {
    return accumulate(begin(array), end(array), 0.0, [](auto const& alpha, auto const& omega) { return alpha + power(omega); });
}

Esta é uma função de "poder" recursiva (através de dimensões ou classificações) que, em última análise, fornece a soma dos quadrados dos elementos calculando o poder dos subelementos de dimensão inferior.

O C++ moderno incentiva o uso if constexprpara evitar o uso de SFINAE, como abaixo.

template<class M>
auto power(M const& array) {
    if constexpr(M::rank::value >= 1) {
        return accumulate(begin(array), end(array), 0.0, [](auto const& alpha, auto const& omega) { return alpha + power(omega); });
    } else {
        return std::norm(array);
    }
}

O problema é que parece que a expressão no if constexprtem que ser uma expressão válida em primeiro lugar. Os elementos não possuem um tipo de membro chamado rank, portanto há um erro de compilação.

Existe algum truque para fazer o if constexprpredicado se a expressão for inválida?

c++

1 respostas

  1. Best Answer

    C++20 e mais recente:

    if constexpr (requires{requires std::bool_constant</*condition*/>::value;})

    Há também uma opção menos detalhada:

    if constexpr (requires{requires /*condition*/;})

    Mas o último é pior, porque causa um erro grave se a condição não for conhecida em tempo de compilação, enquanto o primeiro apenas retorna falso.

    O primeiro é usado na biblioteca padrão (veja também Em um requisito aninhado, por que usar requires bool_constant<X>::value;em vez de requires X;? ).

    C++17:

    Use o idioma de detecção:

    #include <type_traits>

namespace detail
{
    template <typename ...P> struct void_type {using type = void;};

    template <typename DummyVoid, template <typename...> typename A, typename ...B> struct is_detected : std::false_type {};
    template <template <typename...> typename A, typename ...B> struct is_detected<typename void_type<A<B...>>::type, A, B...> : std::true_type {};
}

template <template <typename...> typename A, typename ...B>
inline constexpr bool is_detected = detail::is_detected<void, A, B...>::value;

    Então:

    template <typename M>
using CheckRank = std::enable_if_t<M::rank::value >= 1>;

    if constexpr (is_detected<CheckRank, M>)
    • 4

relate perguntas