Início / coding / Perguntas / 79493652
Accepted
DBS4261
Asked: 2025-03-08 07:59:28 +0800 CST

Crie uma variante de uma matriz cujos elementos são transformados em tipos

  • 772

Eu me deparei com um desafio estranho ao tentar definir um tipo com base em uma matriz enquanto escrevia um código de vinculação de biblioteca.

Considere uma enumeração como a seguinte:

enum class MyTypes
{
    UInt,
    Int,
    Float
}

Com algumas características de tipo, posso converter um valor da enumeração em um tipo:

template <MyTypes Ty> struct typeify;
template <> struct typeify<MyTypes::UInt> { using type = unsigned int; };
template <> struct typeify<MyTypes::Int> { using type = int; };
template <> struct typeify<MyTypes::Float> { using type = float; };
template <MyTypes Ty> using typeify_t = typename typeify<Ty>::type;

Para ajudar com a vinculação, também tenho isso (porque C++ não tem reflexão):

inline static constexpr std::array KnownTypes 
{ 
    std::pair{"UInt", MyTypes::UInt},
    std::pair{"Int", MyTypes::Int},
    std::pair{"Float", MyTypes::Float}
};

A partir daqui, quero definir um std::variantcom base nos meus tipos conhecidos.

Com 3 valores, o óbvio é escrever a variante assim:

std::variant<unsigned int, int, float>

Mas, na minha situação, tenho mais de 50 tipos. Então, eu gostaria de uma maneira de gerar automaticamente a definição de tipo para o std::variantfrom the array of KnownTypese o typeify_ttype trait.

Acho que cheguei perto com o seguinte, mas fiquei bloqueado por não conseguir dar um valor padrão a um parâmetro de modelo variádico:

template <template <typename T, T ... Idx> class temp = std::make_index_sequence<KnownTypes.size()>>
using AnyKnownType = std::variant<typeify_t<KnownTypes[Idx].second>, ...>;
c++

3 respostas

  1. Best Answer

    Qualquer problema na programação pode ser resolvido com outro nível de indireção (exceto muitos níveis de indireção).

    Em vez de criar diretamente um usingmodelo de expressão, crie uma declaração de modelo de função e use seu tipo de retorno na sua usingexpressão:

    template <std::size_t... Is>
std::variant<typeify_t<KnownTypes[Is].second>...>
make_variant_type(std::index_sequence<Is...>);

using AnyKnownType = decltype(make_variant_type(std::make_index_sequence<KnownTypes.size()>()));

    Demonstração

    • 3

  2. Usando a especialização parcial, proponho:

    #include <variant>
#include <cstddef>

// Helper template to generate a variant type from KnownTypes.
template <typename IndexSeq> struct variant_maker_impl;

template <std::size_t... Is> struct variant_maker_impl<std::index_sequence<Is...>>
{
    using type = std::variant< typeify_t<KnownTypes[Is].second>... >;
};

// Alias for the generated variant type.
using AnyKnownType = typename variant_maker_impl<std::make_index_sequence<KnownTypes.size()>>::type;

    Até onde eu sei, essa é a opção que você poderia facilmente inventar. Devido às regras do C++ em modelos de alias, você não pode especializar diretamente e parcialmente um modelo de alias . Modelos de alias não permitem especialização parcial, o que significa que você não pode escrever um alias que "desembrulhe" uma sequência de índice sem usar uma estrutura auxiliar. Portanto, converter de cima para sua abordagem não é possível.

    (( Veja demonstração ao vivo ))

    • 3

  3. Na verdade, você definiu 3 sequências diferentes para sua estrutura:

    • a enumeração

    • a lista de especializações de modelos

    • a matriz que vincula um valor enum a uma string

    Você poderia pelo menos reduzir para 2 sequências da seguinte forma:

    1. uma matriz contendo os valores enum

    2. a lista de especializações de template. Como elas são relacionadas, é melhor colocar lá tanto o tipo quanto a string associada

    Então você pode construir sua variante seguindo a possibilidade de transformar o conteúdo de um array constexpr em um pacote de parâmetros (veja um método geral aqui ), o que leva a:

    #include <array>
#include <variant>

#define VALUES UInt, Int, Float
enum  MyTypes {VALUES};
constexpr std::array MyTypesArray = {VALUES};

template <MyTypes Ty> struct typeify;
template <> struct typeify<MyTypes::UInt>  { constexpr static const char* name="UInt";  using type = unsigned int; };
template <> struct typeify<MyTypes::Int>   { constexpr static const char* name="Int";   using type = int;          };
template <> struct typeify<MyTypes::Float> { constexpr static const char* name="Float"; using type = float;        };

////////////////////////////////////////////////////////////////////////////////
// see https://stackoverflow.com/questions/60434033/how-do-i-expand-a-compile-time-stdarray-into-a-parameter-pack
template <auto arr, template <auto...> typename Consumer, typename IS = decltype(std::make_index_sequence<arr.size()>())>
struct Generator;

template <auto arr, template <auto...> typename Consumer, std::size_t... I>
struct Generator<arr, Consumer, std::index_sequence<I...>> 
{
    using type = Consumer<arr[I]...>;
};

////////////////////////////////////////////////////////////////////////////////
template <auto...s> 
struct ToVariantConsumer  { using type = std::variant <typename typeify<s>::type...>;  };

using AnyKnownType = typename Generator<MyTypesArray, ToVariantConsumer>::type::type;

static_assert (std::is_same_v<AnyKnownType, std::variant<unsigned int, int, float> >);

////////////////////////////////////////////////////////////////////////////////
int main() {}

    Observe o não tão bonito #defineusado para evitar redundância tanto na definição da enumeração quanto na definição de um array contendo todos os valores da enumeração (essa é outra história e parece que existem soluções).

    Observe também que ele será executado a partir de c++20(ou seja, uso de parâmetro de modelo não-tipo de tipo de classe na Generatordefinição).

    • 1

relate perguntas