如何迭代std::variant的类型?
How to iterate over the types of std::variant?
我有一些变体 using V = std::variant<A, B, C>
和一个带有原型的函数 V parse(const json&)
。该函数应该尝试解析所有类型(例如 A
、B
,然后是 C
)直到第一次成功(并且它应该隐式地解析,因为及时会有很多类型).
如何实现这种东西?
我们可能会以某种方式使用std::variant_size
。
Here 接近我需要的东西。
我的解决方案是明确列出所有类型的解析器。
V parse(const json& i_j)
{
using Parser = std::function<MaybeV(const json&)>;
static const auto ps = std::vector<Parser>{
[](const auto& j)->MaybeV{return j.get<std::optional<A>>;},
[](const auto& j)->MaybeV{return j.get<std::optional<B>>;},
[](const auto& j)->MaybeV{return j.get<std::optional<C>>;}
};
for (const auto& p : ps)
if (auto opt_result = p(i_j))
return std::move(*opt_result);
throw ParseError("Can't parse");
}
但它肯定可以简化,因为lambdas只是类型不同,我真正需要的是遍历[=18=].
的类型
您需要从 0 到变体大小减 1 的编译时整数,并且可能提前退出迭代它们。
有很多方法可以获取编译时整数。我最喜欢的两个是生成整型常量元组,或者使用整型常量参数包调用延续。
取整数常量版本的元组,可以用一个“tuple for each”依次访问each。
template<std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
template<std::size_t I>
constexpr index_t<I> index{};
template<std::size_t...Is>
constexpr std::tuple< index_t<Is>... > make_indexes(std::index_sequence<Is...>){
return std::make_tuple(index<Is>...);
}
template<std::size_t N>
constexpr auto indexing_tuple = make_indexes(std::make_index_sequence<N>{});
来自您所说的变体尺寸。从中你调用 tuple_foreach.
如果解析成功但尚未解析,tuple_foreach 会放置可选的 return 值。
V parse(const json& j)
{
auto indexes = indexing_tuple<tuple_size_v<V>>;
std::optional<V> retval;
tuple_foreach(indexes, [&](auto I){ // I is compile time integer
if(retval) return;
auto p = j.get<tuple_alternative_t<I>>();
if(p) retval.emplace(std::move(*p));
});
if(!retval) throw ParseError("Can't parse");
return std::move(*retval);
}
tuple_foreach
可以在网上找到,但为了完整起见:
template<std::size_t...Is, class T, class F>
auto tuple_foreach( std::index_sequence<Is...>, T&& tup, F&& f ) {
( f( std::get<Is>( std::forward<T>(tup) ) ), ... );
}
template<class T, class F>
auto tuple_foreach( T&& tup, F&& f ) {
auto indexes = std::make_index_sequence< std::tuple_size_v< std::decay_t<T> > >{};
return tuple_foreach( indexes, std::forward<T>(tup), std::forward<F>(f) );
}
应该在 c++17.
中完成
类型可以递归处理,从 0
到 std::variant_size_v
(不包括),if-constexpr
限制模板实例化:
#include <variant>
#include <optional>
#include <cstddef>
#include <utility>
using V = std::variant<A, B, C>;
template <std::size_t I = 0>
V parse(const json& j)
{
if constexpr (I < std::variant_size_v<V>)
{
auto result = j.get<std::optional<std::variant_alternative_t<I, V>>>();
return result ? std::move(*result) : parse<I + 1>(j);
}
throw ParseError("Can't parse");
}
我有一些变体 using V = std::variant<A, B, C>
和一个带有原型的函数 V parse(const json&)
。该函数应该尝试解析所有类型(例如 A
、B
,然后是 C
)直到第一次成功(并且它应该隐式地解析,因为及时会有很多类型).
如何实现这种东西?
我们可能会以某种方式使用std::variant_size
。
Here 接近我需要的东西。
我的解决方案是明确列出所有类型的解析器。
V parse(const json& i_j)
{
using Parser = std::function<MaybeV(const json&)>;
static const auto ps = std::vector<Parser>{
[](const auto& j)->MaybeV{return j.get<std::optional<A>>;},
[](const auto& j)->MaybeV{return j.get<std::optional<B>>;},
[](const auto& j)->MaybeV{return j.get<std::optional<C>>;}
};
for (const auto& p : ps)
if (auto opt_result = p(i_j))
return std::move(*opt_result);
throw ParseError("Can't parse");
}
但它肯定可以简化,因为lambdas只是类型不同,我真正需要的是遍历[=18=].
的类型您需要从 0 到变体大小减 1 的编译时整数,并且可能提前退出迭代它们。
有很多方法可以获取编译时整数。我最喜欢的两个是生成整型常量元组,或者使用整型常量参数包调用延续。
取整数常量版本的元组,可以用一个“tuple for each”依次访问each。
template<std::size_t I>
using index_t = std::integral_constant<std::size_t, I>;
template<std::size_t I>
constexpr index_t<I> index{};
template<std::size_t...Is>
constexpr std::tuple< index_t<Is>... > make_indexes(std::index_sequence<Is...>){
return std::make_tuple(index<Is>...);
}
template<std::size_t N>
constexpr auto indexing_tuple = make_indexes(std::make_index_sequence<N>{});
来自您所说的变体尺寸。从中你调用 tuple_foreach.
如果解析成功但尚未解析,tuple_foreach 会放置可选的 return 值。
V parse(const json& j)
{
auto indexes = indexing_tuple<tuple_size_v<V>>;
std::optional<V> retval;
tuple_foreach(indexes, [&](auto I){ // I is compile time integer
if(retval) return;
auto p = j.get<tuple_alternative_t<I>>();
if(p) retval.emplace(std::move(*p));
});
if(!retval) throw ParseError("Can't parse");
return std::move(*retval);
}
tuple_foreach
可以在网上找到,但为了完整起见:
template<std::size_t...Is, class T, class F>
auto tuple_foreach( std::index_sequence<Is...>, T&& tup, F&& f ) {
( f( std::get<Is>( std::forward<T>(tup) ) ), ... );
}
template<class T, class F>
auto tuple_foreach( T&& tup, F&& f ) {
auto indexes = std::make_index_sequence< std::tuple_size_v< std::decay_t<T> > >{};
return tuple_foreach( indexes, std::forward<T>(tup), std::forward<F>(f) );
}
应该在 c++17.
中完成类型可以递归处理,从 0
到 std::variant_size_v
(不包括),if-constexpr
限制模板实例化:
#include <variant>
#include <optional>
#include <cstddef>
#include <utility>
using V = std::variant<A, B, C>;
template <std::size_t I = 0>
V parse(const json& j)
{
if constexpr (I < std::variant_size_v<V>)
{
auto result = j.get<std::optional<std::variant_alternative_t<I, V>>>();
return result ? std::move(*result) : parse<I + 1>(j);
}
throw ParseError("Can't parse");
}