如何检查std :: variant是否可以保存某种类型

时间:2017-08-26 05:17:47

标签: c++ c++17

我的课程中有一个std::variant。此std::variant类型仅允许保留特定的类型列表。

我有模板函数,允许类的用户将各种值插入std::unordered_map,映射包含此变体类型的值。即,如果用户的类型在特定的类型列表中,则仅允许用户插入值。但是,我不希望用户能够自己定义这个类型列表。

class GLCapabilities
{
public:
    using VariantType = std::variant<GLint64>;  // in future this would have other types

    template <typename T>
    std::enable_if_t<???> AddCapability(const GLenum parameterName)
    {
        if(m_capabilities.count(parameterName) == 0)
        {
            /*... get correct value of type T ... */
            m_capabilities.insert(parameterName,value);
        }
    }

    template<typename T>
    std::enable_if_t<???,T> GetCapability(const GLenum parameterName) const
    {
        auto itr = m_capabilities.find(parameterName);
        if(std::holds_alternative<T>(*itr))
            return std::get<T>(*itr);

        return T;
    }

private:
    std::unordered_map<GLenum,VariantType> m_capabilities;
};

您可以在上面看到???,我该如何查看? std::disjunctionstd::is_same的某种组合?

std::enable_if<std::disjunction<std::is_same<T,/*Variant Types???*/>...>>

为清楚起见,我宁愿不必手动检查每个允许的类型。

6 个答案:

答案 0 :(得分:11)

修改:我实际上挖掘了您的std::disjunction想法,它绝对有效。您只需使用模板专业化提取类型列表。

我整个老式的递归混乱变得简单:

template<typename T, typename VARIANT_T>
struct isVariantMember;

template<typename T, typename... ALL_T>
struct isVariantMember<T, std::variant<ALL_T...>> 
  : public std::disjunction<std::is_same<T, ALL_T>...> {};

原始回答:这是一个完成此操作的简单模板。它的工作原理是返回false空类型列表。对于非空列表,如果第一个类型通过true,则返回std::is_same<>,否则以除第一个类型之外的所有类型递归调用自身。

#include <vector>
#include <tuple>
#include <variant>

// Main lookup logic of looking up a type in a list.
template<typename T, typename... ALL_T>
struct isOneOf : public std::false_type {};

template<typename T, typename FRONT_T, typename... REST_T>
struct isOneOf<T, FRONT_T, REST_T...> : public 
  std::conditional<
    std::is_same<T, FRONT_T>::value,
    std::true_type,
    isOneOf<T, REST_T...>
  >::type {};

// Convenience wrapper for std::variant<>.
template<typename T, typename VARIANT_T>
struct isVariantMember;

template<typename T, typename... ALL_T>
struct isVariantMember<T, std::variant<ALL_T...>> : public isOneOf<T, ALL_T...> {};

// Example:
int main() {
  using var_t = std::variant<int, float>;

  bool x = isVariantMember<int, var_t>::value; // x == true
  bool y = isVariantMember<double, var_t>::value; // y == false

  return 0;
}

N.B。确保在调用之前从T中剥离cv和引用限定符(或将剥离添加到模板本身)。这取决于你的需求,真的。

答案 1 :(得分:4)

template <class T> struct type {};
template <class T> constexpr type<T> type_v{};

template <class T, class...Ts, template<class...> class Tp>
constexpr bool is_one_of(type<Tp<Ts...>>, type<T>) {
    return (std::is_same_v<Ts, T> || ...); 
}

然后在is_one_of(type_v<VariantType>, type_v<T>)中使用enable_if

答案 2 :(得分:2)

您可以避免使用std::enable_if_t并使用基于经典decltype的SFINAE表达式,例如以下示例中的表达式:

#include<variant>
#include<utility>

struct S {
    using type = std::variant<int, double>;

    template<typename U>
    auto f()
    -> decltype(std::declval<type>().emplace<U>(), void()) {
        // that's ok
    }
};

int main() {
    S s;
    s.f<int>();
    //s.f<char>();
}

如果您将注释切换到最后一行,则char的编译时错误不是您的变体所接受的类型。

此解决方案的优点是它很简单,您既没有包含type_traits(已授予,您必须包含utility),也没有使用支持类来获取bool值测试它。
当然,您可以根据每个功能的要求相应地调整返回类型。

wandbox上查看并运行。

否则,如果您可以坚持std::holds_alternative的限制(如果类型在变体的参数列表中多次比较,则调用格式不正确),请注意它是constexpr功能,它只是做你想要的:

#include<type_traits>
#include<variant>
#include<utility>

struct S {
    using type = std::variant<int, double>;

    template<typename U>
    std::enable_if_t<std::holds_alternative<U>(type{})>
    f() {
        // that's ok
    }
};

int main() {
    S s;
    s.f<int>();
    //s.f<char>();
}

如上所述,切换注释,您将得到预期的编译时错误。

wandbox上查看并运行。

答案 3 :(得分:1)

由于您已经在使用C ++ 17,因此fold-expressions使这更容易:

template <class T, class U> struct is_one_of;

template <class T, class... Ts> 
struct is_one_of<T, std::variant<Ts...>>
: std::bool_constant<(std::is_same_v<T, Ts> || ...)>
{ };

为了增加可读性,您可以在班级中添加别名:

class GLCapabilities
{
public:
    using VariantType = std::variant<GLint64>;  // in future this would have other types
    template <class T> using allowed = is_one_of<T, VariantType>;

    template <typename T>
    std::enable_if_t<allowed<T>{}> AddCapability(const GLenum parameterName)
    { ... }
};

答案 4 :(得分:0)

您可以通过从VariantType类型构建T来尝试使用SFINAE。

template <typename T, typename = VariantType(std::declval<T>())>
void AddCapability(T const& t); // not sure how you want to use it.

或使用std::is_constructible<VariantType, T>。毕竟,您可能想知道是否可以从类型中分配/初始化,而不是类型实际上是变体类型之一(更具限制性)。

答案 5 :(得分:0)

#include <type_traits>
#include <variant>


template <typename, typename... T0ToN>
struct is_one_of;

template <typename T>
struct is_one_of<T> : public std::false_type
{
};

template <typename T, typename... T1toN>
struct is_one_of<T, T, T1toN...> : public std::true_type
{
};

template <typename T, typename P, typename... T1toN>
struct is_one_of<T, P, T1toN...> : is_one_of<T, T1toN...>
{
};

template <typename Type, typename ... Others>
struct is_in_variant : public std::false_type {};

template <typename Type, typename ... Others>
struct is_in_variant<Type, std::variant<Others...>> : public is_one_of<Type, Others...>
{};


int main()
{
    std::variant<int, float> v;
    return is_in_variant<double, std::variant<int, float>>::value ? 4 : 8;
}