Início / coding / Perguntas / 79003051
Accepted
MaPo
Asked: 2024-09-19 22:29:28 +0800 CST

Construindo uma std::variant de ponteiros de tipos nas alternativas de outra std::variant

  • 772

Recebi um std::variantde vários tipos. Gostaria de escrever um traço que fornece outro std::variantdo ponteiro dos tipos do primeiro.

using MyVariant = std::variant<int, float>;

using MyVariantOfPointers = pointer_of_v<MyVariant>;

tal que MyVariantOfPointeré std::variant<int*, float*>. Eu tentei brincar com std::variant_size_ve std::variant_alternative_tmas não sei como construir o novo tipo recursivamente.

c++

2 respostas

  1. Best Answer

    Você pode usar especialização parcial para escrever uma característica para resolver isso.

    // General case
template<class T>
struct VariantToPtrVariant;

// Partial specialization when used with std::variant
// Extracts the template arguments from the `std::variant` and 
//  produces a new `std::variant` with those types, with an added `*`
template<class ... T>
struct VariantToPtrVariant<std::variant<T...>> {
    using type = std::variant<T*...>;
};

// Helper variable template
template<class T>
using VariantToPtrVariant_t = typename VariantToPtrVariant<T>::type;

    Uso:

    using MyVariant = std::variant<int, float>;
using MyVariantOfPointers = VariantToPtrVariant_t<MyVariant>;

    Exemplo completo ( https://godbolt.org/z/qaTxo4nzc ) :

    #include <type_traits>
#include <variant>

template<class T>
struct VariantToPtrVariant;

template<class ... T>
struct VariantToPtrVariant<std::variant<T...>> {
    using type = std::variant<T*...>;
};

template<class T>
using VariantToPtrVariant_t = typename VariantToPtrVariant<T>::type;

using MyVariant = std::variant<int, float>;
using MyVariantOfPointers = VariantToPtrVariant_t<MyVariant>;

static_assert(std::is_same_v<MyVariantOfPointers, std::variant<int*, float*>>);
    • 3

  2. Outra solução que fornece uma solução genérica: aplicar qualquer tipo de functor em qualquer coleção de tipos:

    // Map Template Functor
template<template<class> class Functor, class TCollection>
struct map {};

template<template<class> class Functor, template<class...> class TCollection, class... Types>
struct map<Functor, TCollection<Types...>>
{
    using type = TCollection<Functor<Types> ...>;
};

    Exemplo de uso:

    // Functor to map
template<typename T> using add_pointer_t   = T*;
template<typename T> using add_reference_t = T&;

// Type collection to map on
using MyVariant = std::variant<int, float, double>;
using MyTuple   = std::tuple<MyVariant, int, int>;

// Usage
using MyVariantOfPointers = map_t<add_pointer_t, MyVariant>;
using MyTupleOfPointers   = map_t<add_reference_t, MyTuple>;
static_assert(std::is_same_v<MyVariantOfPointers, std::variant<int*, float*, double*>>);
static_assert(std::is_same_v<MyTupleOfPointers,   std::tuple<std::variant<int, float, double>&, int&, int&>>);

    Demonstração no Compiler Explorer

    • 1

relate perguntas