将 variant、vector<variant> 和 vector<vector<variant>> 转换为我选择的等效类型
Conversion of variant, vector<variant> and vector<vector<variant>> to the equivalent type of my choice
我的问题涉及 C++ 中 boost::variant
转换与 std::vector
的混合。在我的项目中,我使用变体作为 SQL 的输出。我将始终只使用一种类型的变体。我想要做的是从变量、变量向量或变量的 2xvector 到我选择的等效类型的简单转换。天真地,我需要一些类似的东西:
std::vector < int > my_variable = convert(some_variant_vector)
首先是我的设置:
#include "boost\variant.hpp"
#include "boost\date_time\gregorian\gregorian.hpp"
typedef boost::variant< int, std::string, boost::gregorian::date> _var;
typedef std::vector<_var> _vec_var;
typedef std::vector<_vec_var> _vec2_var;
我想要一个简单的方法来根据我的需要将 _var
(或 _vec_var
或 _vec2_var
)转换为 int/string/date。从下面 post 我知道我的答案应该是这样的:
template<typename T>
struct converter_visitor : public boost::static_visitor<T>
{
const _var &converter;
converter_visitor(const _var &r) : converter(r) {}
T operator()(const _var &) const{
return boost::get<_var>(converter);
}
const _vec_var &v_converter; // case of vector<>
converter_visitor(const _vec_var &r) : v_converter(r) {}
T operator()(const _vec_var &) const{
T ans;
ans.reserve(_cont.size());
for (int i = 0; i < _cont.size(); ++i)
ans.push_back(boost::get<T>(v_converter[i]));
return ans;
}
const _vec2_var & v2_converter; // case of vector<vector>
converter_visitor(const _vec2_var &r) : v2_converter(r) {}
T operator()(const _vec2_var &) const {
T ans;
ans.reserve(v2_converter.size(), v2_converter[0].size());
for (int i = 0; i < _cont.size(); ++i)
{
for (size_t j = 0; j < v2_converter[0].size(); j++)
{
ans.push_back(boost::get<T>(v2_converter[i][j]));
}
}
return ans;
}
};
int main()
{
_var variable = 1;
int integer_conversion;
boost::apply_visitor(converter_visitor(test), integer_conversion);
return 0;
}
不幸的是,我被困了一段时间,因为它没有按预期工作,甚至没有编译。
我找到了解决您的问题的方法,正如我在评论中所说,我做了以下操作:
我写了一个 bool_visitor<T>
wich returns true
如果 boost::variant
持有 T
并且 false
否则;
访问者如下:
template<typename T>
struct bool_visitor : public boost::static_visitor<bool> {
inline constexpr bool operator()(T val) const
{
return false;
}
template<typename K>
typename std::enable_if<!std::is_convertible<K, T>::value, bool>::type
operator()(K val) const
{
return true;
}
};
对于这个访问者,我们能够删除不包含特定类型的向量的所有变体。
在此之后,我们使用 std::transform
将所有变体转换为它们所拥有的类型。
我们使用 SFINAE 来检查给定的向量是否为嵌套向量(向量),如果是,我们首先使用 flatten 函数将向量展平:
template <typename FromIter, typename ToIter>
void flatten (FromIter start, FromIter end, ToIter dest) {
while (start != end) {
dest = std::copy(start->begin(), start->end(), dest);
++start;
}
}
为了检查向量是否嵌套,我们需要一个 is_vector
特征:
template<typename>
struct is_vector : std::false_type {};
template<typename T, typename A>
struct is_vector<std::vector<T,A>> : std::true_type {};
现在我们可以使用 SFINAE 在给定向量上启用我们想要的功能:
template<typename T, typename K>
typename
std::enable_if_t<
!is_vector<K>::value,
std::vector<T>>
get_vec_of(std::vector<K>& input_vec){
//delete all variants not holding T
auto it = std::remove_if(input_vec.begin(), input_vec.end(),
[](auto item){
return boost::apply_visitor(bool_visitor<T>(), item);
});
//input_vec.erase(it, input_vec.end());
//create new vector of T
std::vector<T> return_vec;
//transform all variants holding T to T and put them in the return_vec
std::transform(input_vec.begin(), it, std::back_inserter(return_vec),
[](auto item){
//this can never throw because all variants in the vector are holding T
return boost::get<T>(item);
});
return return_vec;
}
template<typename T, typename K>
typename
std::enable_if_t<
is_vector<K>::value,
std::vector<T>>
get_vec_of(std::vector<K>& input_vec){
std::vector<typename K::value_type> flatten_vec;
flatten(input_vec.begin(), input_vec.end(), std::back_inserter(flatten_vec));
return get_vec_of<T>(flatten_vec);
};
这个解决方案改变了给定向量中元素的顺序。如果这对您不利,您也许应该先复制矢量。
here 是关于如何使用此功能及其工作原理的演示。
我会建议以下内容以获得您想要的类型:
template<typename T>
class converter_visitor : public boost::static_visitor<>
{
public:
std::vector<T>& vec;
converter_visitor(std::vector<T>& r) : vec(r) {}
// only push back values of specific types...
void operator()(const T& u) const {
vec.push_back(u);
}
// ignore other types...
void operator()(...) const {}
};
template<typename T>
converter_visitor<T> make_visitor(std::vector<T>& r) { return converter_visitor<T>(r); }
然后将其汇集到可以处理嵌套向量的递归过滤器函数:
template<typename T,typename U>
void filter(std::vector<T>& result,const U& var) {
boost::apply_visitor( make_visitor(result), var );
}
template<typename T,typename U>
void filter(std::vector<T>& result,const std::vector<U>& cont) {
std::for_each(cont.begin(),cont.end(),[&](const U& c) {
filter(result,c);
});
}
那么你可以这样做:
_var v = 314;
std::vector<int> result;
filter(result,v);
print(result);
result: 314
_vec_var v;
v.push_back(2);
v.push_back(3);
v.push_back("hello");
v.push_back(5);
v.push_back(7);
v.push_back("world");
std::vector<int> result;
filter(result,v);
print(result);
std::vector<std::string> result2;
filter(result2,v);
print(result2);
result1: 2 3 5 7
result2: hello world
_vec_var v1;
v1.push_back(11);
v1.push_back(13);
v1.push_back("see ya");
_vec_var v2;
v2.push_back(17);
v2.push_back(19);
v2.push_back("later");
_vec2_var vv;
vv.push_back(v1);
vv.push_back(v2);
std::vector<int> result;
filter(result,vv);
print(result);
std::vector<std::string> result2;
filter(result2,vv);
print(result2);
result1: 11 13 17 19
result2: see ya later
我的问题涉及 C++ 中 boost::variant
转换与 std::vector
的混合。在我的项目中,我使用变体作为 SQL 的输出。我将始终只使用一种类型的变体。我想要做的是从变量、变量向量或变量的 2xvector 到我选择的等效类型的简单转换。天真地,我需要一些类似的东西:
std::vector < int > my_variable = convert(some_variant_vector)
首先是我的设置:
#include "boost\variant.hpp"
#include "boost\date_time\gregorian\gregorian.hpp"
typedef boost::variant< int, std::string, boost::gregorian::date> _var;
typedef std::vector<_var> _vec_var;
typedef std::vector<_vec_var> _vec2_var;
我想要一个简单的方法来根据我的需要将 _var
(或 _vec_var
或 _vec2_var
)转换为 int/string/date。从下面 post 我知道我的答案应该是这样的:
template<typename T>
struct converter_visitor : public boost::static_visitor<T>
{
const _var &converter;
converter_visitor(const _var &r) : converter(r) {}
T operator()(const _var &) const{
return boost::get<_var>(converter);
}
const _vec_var &v_converter; // case of vector<>
converter_visitor(const _vec_var &r) : v_converter(r) {}
T operator()(const _vec_var &) const{
T ans;
ans.reserve(_cont.size());
for (int i = 0; i < _cont.size(); ++i)
ans.push_back(boost::get<T>(v_converter[i]));
return ans;
}
const _vec2_var & v2_converter; // case of vector<vector>
converter_visitor(const _vec2_var &r) : v2_converter(r) {}
T operator()(const _vec2_var &) const {
T ans;
ans.reserve(v2_converter.size(), v2_converter[0].size());
for (int i = 0; i < _cont.size(); ++i)
{
for (size_t j = 0; j < v2_converter[0].size(); j++)
{
ans.push_back(boost::get<T>(v2_converter[i][j]));
}
}
return ans;
}
};
int main()
{
_var variable = 1;
int integer_conversion;
boost::apply_visitor(converter_visitor(test), integer_conversion);
return 0;
}
不幸的是,我被困了一段时间,因为它没有按预期工作,甚至没有编译。
我找到了解决您的问题的方法,正如我在评论中所说,我做了以下操作:
我写了一个 bool_visitor<T>
wich returns true
如果 boost::variant
持有 T
并且 false
否则;
访问者如下:
template<typename T>
struct bool_visitor : public boost::static_visitor<bool> {
inline constexpr bool operator()(T val) const
{
return false;
}
template<typename K>
typename std::enable_if<!std::is_convertible<K, T>::value, bool>::type
operator()(K val) const
{
return true;
}
};
对于这个访问者,我们能够删除不包含特定类型的向量的所有变体。
在此之后,我们使用 std::transform
将所有变体转换为它们所拥有的类型。
我们使用 SFINAE 来检查给定的向量是否为嵌套向量(向量),如果是,我们首先使用 flatten 函数将向量展平:
template <typename FromIter, typename ToIter>
void flatten (FromIter start, FromIter end, ToIter dest) {
while (start != end) {
dest = std::copy(start->begin(), start->end(), dest);
++start;
}
}
为了检查向量是否嵌套,我们需要一个 is_vector
特征:
template<typename>
struct is_vector : std::false_type {};
template<typename T, typename A>
struct is_vector<std::vector<T,A>> : std::true_type {};
现在我们可以使用 SFINAE 在给定向量上启用我们想要的功能:
template<typename T, typename K>
typename
std::enable_if_t<
!is_vector<K>::value,
std::vector<T>>
get_vec_of(std::vector<K>& input_vec){
//delete all variants not holding T
auto it = std::remove_if(input_vec.begin(), input_vec.end(),
[](auto item){
return boost::apply_visitor(bool_visitor<T>(), item);
});
//input_vec.erase(it, input_vec.end());
//create new vector of T
std::vector<T> return_vec;
//transform all variants holding T to T and put them in the return_vec
std::transform(input_vec.begin(), it, std::back_inserter(return_vec),
[](auto item){
//this can never throw because all variants in the vector are holding T
return boost::get<T>(item);
});
return return_vec;
}
template<typename T, typename K>
typename
std::enable_if_t<
is_vector<K>::value,
std::vector<T>>
get_vec_of(std::vector<K>& input_vec){
std::vector<typename K::value_type> flatten_vec;
flatten(input_vec.begin(), input_vec.end(), std::back_inserter(flatten_vec));
return get_vec_of<T>(flatten_vec);
};
这个解决方案改变了给定向量中元素的顺序。如果这对您不利,您也许应该先复制矢量。
here 是关于如何使用此功能及其工作原理的演示。
我会建议以下内容以获得您想要的类型:
template<typename T>
class converter_visitor : public boost::static_visitor<>
{
public:
std::vector<T>& vec;
converter_visitor(std::vector<T>& r) : vec(r) {}
// only push back values of specific types...
void operator()(const T& u) const {
vec.push_back(u);
}
// ignore other types...
void operator()(...) const {}
};
template<typename T>
converter_visitor<T> make_visitor(std::vector<T>& r) { return converter_visitor<T>(r); }
然后将其汇集到可以处理嵌套向量的递归过滤器函数:
template<typename T,typename U>
void filter(std::vector<T>& result,const U& var) {
boost::apply_visitor( make_visitor(result), var );
}
template<typename T,typename U>
void filter(std::vector<T>& result,const std::vector<U>& cont) {
std::for_each(cont.begin(),cont.end(),[&](const U& c) {
filter(result,c);
});
}
那么你可以这样做:
_var v = 314;
std::vector<int> result;
filter(result,v);
print(result);
result: 314
_vec_var v;
v.push_back(2);
v.push_back(3);
v.push_back("hello");
v.push_back(5);
v.push_back(7);
v.push_back("world");
std::vector<int> result;
filter(result,v);
print(result);
std::vector<std::string> result2;
filter(result2,v);
print(result2);
result1: 2 3 5 7
result2: hello world
_vec_var v1;
v1.push_back(11);
v1.push_back(13);
v1.push_back("see ya");
_vec_var v2;
v2.push_back(17);
v2.push_back(19);
v2.push_back("later");
_vec2_var vv;
vv.push_back(v1);
vv.push_back(v2);
std::vector<int> result;
filter(result,vv);
print(result);
std::vector<std::string> result2;
filter(result2,vv);
print(result2);
result1: 11 13 17 19
result2: see ya later