我的课程中有一个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::disjunction
与std::is_same
的某种组合?
像
std::enable_if<std::disjunction<std::is_same<T,/*Variant Types???*/>...>>
为清楚起见,我宁愿不必手动检查每个允许的类型。
答案 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;
}