展平一系列序列（序列的序列）
我正在使用 boost::fusion。
假设我有类似以下内容的内容：
make_vector(1, make_vector('b', 3, make_vector(4, 5.5), "six"), 7, 8)
我想生成一个函数 f ，即
f(make_vector(1, make_vector('b', 3, make_vector(4, 5.5), "six"), 7, 8))
-> [1, 'b', 3, 4, 5.5, "six", 7, 8]
序列的扁平版本。
我不介意这是原始序列的视图还是实际的向量。
如果 C++0x 中的解决方案可以在 GCC 4.5.1 上编译，我不介意。
注意：
虽然我不想限制数据元素，但如果有帮助的话，请随意要求“数据”元素全部派生自一个公共基类。
即
class DataBase {}
template <class T>
class Data : public DataBase
{
public:
Data(const T& x) : m_x(x)
T m_x;
}
template <class T>
T make_data(const T& x) { return Data<T>(x); }
然后
make_vector(
make_data(1),
make_vector(
make_data('b'),
make_data(3),
make_vector(
make_data(4),
make_data(5.5)
),
make_data("six")
),
make_data(7),
make_data(8)
)
我想你可以通过使用“is_base_of”来计算出数据元素是什么。
I'm using boost::fusion.
Lets say I have something like the following:
make_vector(1, make_vector('b', 3, make_vector(4, 5.5), "six"), 7, 8)
I want to produce an function f such that
f(make_vector(1, make_vector('b', 3, make_vector(4, 5.5), "six"), 7, 8))
-> [1, 'b', 3, 4, 5.5, "six", 7, 8]
i.e. a flattened version of the sequence.
I don't mind if this is a view of the original sequence or an actual vector.
I don't mind a solution in C++0x if it can compile on GCC 4.5.1.
Note:
Whilst I'd prefer not to restrict the data elements, if it helps, feel free to require that the "data" elements all derive from a common base class.
i.e.
class DataBase {}
template <class T>
class Data : public DataBase
{
public:
Data(const T& x) : m_x(x)
T m_x;
}
template <class T>
T make_data(const T& x) { return Data<T>(x); }
Then
make_vector(
make_data(1),
make_vector(
make_data('b'),
make_data(3),
make_vector(
make_data(4),
make_data(5.5)
),
make_data("six")
),
make_data(7),
make_data(8)
)
I figure then you can work out what the data elements are by using "is_base_of".
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（1）
这是一种可能的解决方案，使用
递归加入。基本上，它执行以下操作（在伪 Haskell 中）：递归地将展平的头部连接到展平的尾部。
该解决方案很可能不是最有效的解决方案，因为它构造了许多视图，即使对于单个值也是如此；更好的方法可能是将结果序列作为递归调用中的参数传递，并直接在其中添加各个元素，也许使用
折叠。这是代码（免责声明：我写得很快，因此代码可能充满错误和/或不惯用的做事方式）：
Here is one possible solution, that uses
joinrecursively. Basically, it does the following (in pseudo-Haskell):Recursively, the flattened head is concatenated to the flattened tail.
This solution is very likely not the most efficient one since it constructs many views, even for single values; a better approach could be passing the resulting sequence as a parameter in recursive calls and directly add the individual elements in it, perhaps using
fold.Here is the code (disclaimer: I wrote this quite quickly, so the code could be filled with bugs and/or non-idiomatic ways of doing things):