Início / coding / Perguntas / 79541531
Accepted
Andrea Bocco
Asked: 2025-03-28 21:17:10 +0800 CST

Por que a expansão de pacote falha no meu traço de tipo de transformação std::tuple?

  • 772

Estou tentando construir a versão "tuplada" de tempo de compilação de std::transform. Este tipo de características deve receber um std::tuple, uma característica de tipo unário que "retorna" um tipo (como std::remove_pointer) e deve produzir um std::tuplecujos tipos são o resultado da aplicação da característica de tipo ao tipo correspondente da entradastd::tuple

Por exemplo, my_tuple_trasform<std::tuple<int*, float&, double*>, std::remove_pointer>::typedeve ser equivalente a std::tuple<int, float&, double>.

Eu poderia facilmente escrever uma solução recursivamente, mas estava tentando implementar uma solução "iterativa" por meio de um pacote de expansão e não consigo descobrir o que estou fazendo de errado.

Aqui está meu código:

template <typename Tuple, template<typename> typename TraitPredicate>
struct my_tuple_trasform;

template <template<typename> typename TraitPredicate, typename... Ts>
struct my_tuple_trasform<std::tuple<Ts...>, TraitPredicate>
{
    using type = std::tuple<(typename TraitPredicate<Ts>::type)...>;
};

O compilador produz um erro inútil, onde aponta que a expressão

(typename TraitPredicate<Ts>::type)

não é reconhecido como um pacote de parâmetros e também parece pensar que a coisa toda, reticências incluídas, é apenas o primeiro tipo do std::tuple.

c++

2 respostas

  1. Best Answer

    Foi por pouco: você tem que pular os parênteses emusing type = std::tuple<(typename TraitPredicate<Ts>::type)...>;

    #include <tuple>

template <typename Tuple, template<typename> typename TraitPredicate>
struct my_tuple_trasform;

template <template<typename> typename TraitPredicate, typename... Ts>
struct my_tuple_trasform<std::tuple<Ts...>, TraitPredicate>
{
    using type = std::tuple<typename TraitPredicate<Ts>::type...>;
};

using T1 = std::tuple<int*, float&, double*>;
using T2 = my_tuple_trasform<T1, std::remove_pointer>::type;

static_assert (std::is_same_v<T2, std::tuple<int, float&, double>>);

int main() {}

    Demonstração

    • 6

  2. O erro foi causado pelo encapsulamento da expansão do pacote em parênteses extras, o que impediu o compilador de reconhecê-lo como uma expansão do pacote e o fez tratar a expressão como um único tipo. Isso já foi mencionado na outra resposta.

    No entanto, aqui está uma solução um pouco menos detalhada usando lambda modelado (requer ou posterior) com decltype:

    #include <tuple>
#include <type_traits>

template <typename Tuple, template<typename> typename TraitPredicate>
using my_tuple_transform_t = decltype([]<typename... Ts>(std::tuple<Ts...>*)
    -> std::tuple<typename TraitPredicate<Ts>::type...> { return {}; }
                                      (static_cast<Tuple*>(nullptr)));

    (( Veja demonstração ao vivo ))

    Ou para o caso de compiladores mais antigos:

    // Helper function template that is never defined, exists solely for type deduction.
template <template<typename> class TraitPredicate, typename... Ts>
auto transform_tuple_impl(std::tuple<Ts...>*) -> std::tuple<typename TraitPredicate<Ts>::type...>;

// Type alias that uses the helper function with decltype to deduce the transformed tuple type.
template <typename Tuple, template<typename> class TraitPredicate>
using my_tuple_transform_t = decltype(transform_tuple_impl<TraitPredicate>(static_cast<Tuple*>(nullptr)));

    (( Veja demonstração ao vivo ))

    • 4

relate perguntas