将variant，vector <variant>和vector <vector <variant >>转换为我选择的等效类型

Question

我的问题涉及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。从下面的帖子中，我知道我的答案应该类似于以下内容：

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

不幸的是，由于它无法按预期运行，甚至无法编译，因此我对此一直停留了一段时间。

Answer 1

我建议以下内容来获取所需的类型：

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

结果：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：你好世界

_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：稍后再见

在这里观看现场演示