主页 / coding / 问题 / 79003051
Accepted
MaPo
Asked: 2024-09-19 22:29:28 +0800 CST

构建一个 std::variant 类型的指针，该指针属于另一个 std::variant 的替代方案

  • 772

我得到了std::variant几种类型的一个。我想编写一个特征，为另一个特征提供std::variant第一种类型的指针。

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

using MyVariantOfPointers = pointer_of_v<MyVariant>;

MyVariantOfPointer就是这样std::variant<int*, float*>。我尝试使用std::variant_size_v和，std::variant_alternative_t但我不知道如何递归构建新类型。

c++

2 个回答

  1. Best Answer

    您可以使用部分专门化来编写特征来解决这个问题。

    // 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;

    用法 ：

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

    完整示例（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. 提供通用解决方案的另一种解决方案：将任何类型的函子应用于任何类型的集合：

    // 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> ...>;
};

    使用示例：

    // 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&>>);

    Compiler Explorer 上的演示

    • 1

相关问题