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

Question

我的问题涉及C++中boost::variant转换与std::vector的混合使用。在我的项目中，我使用变量作为SQL的输出。我将始终只使用一种类型的变量。我想做的是从变量、变量向量或2x变量向量轻松地转换为我选择的等效类型。天真地说，我需要以下内容：

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

很不幸，我已经被这个问题困扰了一段时间，因为它不能按照预期工作，甚至无法编译。

- Thierry Prost

---

在同一个 std::vector 中，boost::variant 是否可能一次保留一个 std::string，另一次保留一个 int？ - Exagon

哦，是的，这完全可以实现。但我的向量始终将保持相同的类型。 - Thierry Prost

如果您调用 std::vector <int> my_variable = convert(some_variant_vector)，您希望获得在 some_variant_vector 中持有 int 的所有变量的 int 值？ - Exagon

是的，“some_variant_vector”将只包含int、string或date中的一种类型。我必须承认这是variant的一个不太常见的用法，但我无法没有它。 - Thierry Prost

我的想法是编写一个 bool_visitor<T>，如果一个 boost::variant 包含 T，则返回 true，否则返回 false。然后使用 std::remove 删除所有不包含 T 的变量，再使用 std::transform 将向量中的所有变量转换为它们所持有的类型。 如果这对您有用，我会尝试一下。 - Exagon

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

结果1: 2 3 5 7
结果2: 你好世界

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

结果1：11 13 17 19
结果2：待会儿见

在这里查看演示

- Biggy Smith

---

这是一个很棒的答案。 - Thierry Prost

Answer 2

我发现了解决您问题的方法，就如我在评论中所说，我做了以下事情：

我编写了一个名为 bool_visitor<T> 的访问器，如果一个 boost::variant 包含 T，则返回true，否则返回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检查给定的向量是否是嵌套向量（向量），如果是，则首先使用扁平化函数将其扁平化：

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

这个解决方案会改变给定向量中的元素顺序。如果这对您不利，您可能应该先复制向量。 这里是一个演示如何使用此函数以及它是如何工作的。

- Exagon