如何在运行时填充boost :: fusion :: vector？

本文介绍了如何在运行时填充boost :: fusion :: vector？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

首先，请对与我上一个问题的相似性道歉，，但我不认为我问正确的事。

Firstly, apologies for the similarity to my previous question here, but I don't think I asked the right thing.

我有一个方法：

template <typename T>
void some_method( T &t)
{...}

其采用要在运行时确定的类型 fusion :: vector 在另一个

which takes a type fusion::vector<T1, T2, T3, ..., Tn> to be determined at runtime - e.g. vector<int, double> in one call and vector<int, double, int> in another.

我想用如下动态填充此向量：

I want to fill this vector dynamically with something like:

int blah = 5;
for(int i = 0; i<size(t); i++){
at_c<i>(t) = blah;
}

这不起作用，因为at_c期望一个 const

This doesn't work since at_c expects a const.

我试过其他的东西（见上一个问题），但仍然无法解决这个问题。

I've tried other stuff (see the previous question) but still can't work out how to achieve this.

任何帮助非常感谢！
感谢。

Any help much appreciated!Thanks.

推荐答案

由于@Mankarse指定正确，所以不能使用 fusion for 循环中的 / code>容器，这是因为 fusion 容器都是 tuple ，每个元素可能与其他元素有不同的类型，所有通过融合容器迭代的函数实际上是一对函数，作为模板或重载的函数。因此，为了从向量初始化一个融合容器，您应该有多个函数编译为多个类或函数），它们都可以访问该向量（或者至少是来自向量的一个迭代器和一个可以为每个调用增加的状态变量）。因此，您有两个选项：

As @Mankarse specified correctly, you can't use fusion containers in a for loop and that's because fusion containers are all about tuple and each element may have different type from other elements, all functions that iterate through a fusion container are actually a couple of functions and usually implemented as template or overloaded functions. So in order to initialize a fusion container from a vector you should have multiple functions (or simply a template that will be compiled to multiple classes or functions) that all have access to that vector(or at least an iterator from the vector and an state variable that can increased for each call). So you have 2 options:

1）使用boost :: fusion :: fold：

1) Use boost::fusion::fold:

template< class StdIteratorT >
struct initialize_fusion_container_from_std_iterator {
    typedef StdIteratorT    result_type;

    template< class T >
    StdIteratorT operator()( StdIteratorT i, T& val ) {
        val = *i;
        return ++i;
    }
};
void use_fold_demo() {
    int p1[] = {4, 5, 6};
    fusion::vector<int, double, int> fv;
    std::vector<int> sv2( p1, p1 + _countof(p1) );
    fusion::fold( fv, sv2.begin(),
    initialize_fusion_container_from_std_iterator<std::vector<int>::iterator>() );
}

2）编写一个函数，递归地调用下一个容器记住这个函数的语法就像递归函数，但它不是递归的）：

2) Write a function that recursively call itself with next item of the container(remember syntax of this function is like recursive functions but it is not recursive at all):

// this will be called when we reach end of the fusion container(FIBeginT==FIEndT)
template< class FIBeginT, class FIEndT, class StdIteratorT >
void set_fusion_iterator( FIBeginT b, FIEndT e, StdIteratorT i, boost::mpl::true_ )
{
}
// this will be called when FIBeginT != FIEndT
template< class FIBeginT, class FIEndT, class StdIteratorT >
void set_fusion_iterator( FIBeginT b, FIEndT e, StdIteratorT i, boost::mpl::false_ )
{
    *b = *i;
    set_fusion_iterator( fusion::next(b), e, ++i,
        fusion::result_of::equal_to<
            typename fusion::result_of::next<FIBeginT>::type, FIEndT >() );
}

void recursive_function_demo() {
    typedef fusion::vector<int, double, int>    my_fusion_vector;

    int p1[] = {1, 2, 3};
    std::vector<int> sv1( p1, p1 + _countof(p1) );
    fusion::vector<int, double, int> fv;
    set_fusion_iterator( fusion::begin(fv), fusion::end(fv), sv1.begin(),
        fusion::result_of::equal_to<
            typename fusion::result_of::end<my_fusion_vector>::type,
            typename fusion::result_of::begin<my_fusion_vector>::type>() );
}

正如你看到的第二种情况要复杂得多，你可以使用它来做任何 fusion 容器，所以选择是你的所有！

As you see second case is much more complicated, but if you understand its logic you can use it to do anything with fusion containers, so the choice is all yours!!

这篇关于如何在运行时填充boost :: fusion :: vector？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！

Fusion