Question

我的问题涉及C ++中String转换与boost::variant的混合。在我的项目中，我使用变量作为SQL的输出。我将永远只使用一种变体。我想要做的是从变体，变体的向量或变量的2xvector到我选择的等效类型的简单转换。天真地，我需要的是：

std::vector

首先是我的设置：

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）转换为int / string / date。从以下post我知道我的答案应该是这样的：

_vec2_var

不幸的是，我已经被困住了一段时间，因为它没有按预期工作，甚至没有编译。

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

see live demo here

Answer 2

我找到了解决问题的方法，正如我在评论中所说，我做了以下事情：

我写了一个bool_visitor<T>，如果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

通过此访问者，我们可以删除不包含特定类型的矢量的所有变体。在此之后，我们使用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; } }将所有变体转换为它们所持有的类型。我们使用SFINAE来检查给定的向量是否是嵌套向量（向量），如果是这样，我们首先使用展平函数展平向量：

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 {};特征：

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

现在我们可以使用SFINAE在给定的向量上启用我们想要的功能：

__init__

此解决方案更改给定向量内元素的顺序。如果这对你不利，你可能应该先复制矢量。

here是关于如何使用此功能以及它如何工作的演示。

变体，载体<variant>和载体<vector <variant>的转换＆gt;到我选择的同等类型

2 个答案: