C++: boost::fusion::for_each для многих последовательностей
В настоящее время boost::fusion::for_each перебирает элементы одной последовательности. Я пытаюсь создать функцию, которая будет работать аналогичным образом, но со многими последовательностями и будет перебирать все возможные комбинации между последовательностями.
Например, если у меня есть три последовательности S1, S2, S3, я хотел бы создать такой функтор, как этот
struct my_functor {
template <class x, class y, class z>
void operator()(x& el1, y& el2, z& el3) {...}
}
а затем позвоните
for_each(s1, s2, s3, my_functor()) // applies the functor to all combinations of elements of s1, s2, s3
где s1, s2, s3 являются экземплярами S1, S2, S3.
Я начал с написания кода для общего случая (любое количество последовательностей), но нашел его слишком сложным. Поэтому я решил начать с двух последовательностей и взять их оттуда. Мне удалось сделать это, когда у меня есть две последовательности (предполагая fusion::vectors для простоты), как это:
//for_each.hpp
#include <boost/fusion/include/mpl.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/include/back.hpp>
#include <boost/mpl/size.hpp>
template <class Seq1, class Seq2, int i1, int i2, class F>
struct my_call {
static void apply(Seq1& seq1, Seq2& seq2, F& f) {
f(boost::fusion::at_c<i1>(seq1), boost::fusion::at_c<i2>(seq2)); // apply functor for a given pair of ints
my_call<Seq1, Seq2, i1, i2+1, F>::apply(seq1, seq2, f); // increase second int by 1 and apply functor again
}
};
// terminal condition for 2nd sequence
template <class Seq1, class Seq2, int i1, class F>
struct my_call<Seq1, Seq2, i1, boost::mpl::size<Seq2>::type::value - 1, F> {
static void apply(Seq1& seq1, Seq2& seq2, F& f) {
f(boost::fusion::at_c<i1>(seq1), boost::fusion::back(seq2));
my_call<Seq1, Seq2, i1+1, 0, F>::apply(seq1, seq2, f); // reset 2nd int and increase 1st by 1
}
};
// terminal condition for both sequences
template <class Seq1, class Seq2, class F>
struct my_call<Seq1, Seq2, boost::mpl::size<Seq2>::type::value - 1, boost::mpl::size<Seq2>::type::value - 1, F> {
static void apply(Seq1& seq1, Seq2& seq2, F& f) {
f(boost::fusion::back(seq1), boost::fusion::back(seq2));
}
};
// the actual function
template <class Seq1, class Seq2, class F>
void for_each(Seq1& seq1, Seq2& seq2, F& f) {
my_call<Seq1, Seq2, 0, 0, F>::apply(seq1, seq2, f);
}
а главное как
//main.cpp
#include "for_each.hpp"
#include <iostream>
struct myf {
template <class X, class Y>
void operator()(X& x, Y& y) {
std::cout << x + y << std::endl;
}
};
int main() {
boost::fusion::vector<int, double> x(1, 2.5);
boost::fusion::vector<double, int> y(2, 5);
myf F;
for_each(x, y, F);
return 0;
}
Моя основная проблема (без каламбура) - обобщение вышесказанного, чтобы оно работало с любым количеством последовательностей. Любые предложения приветствуются! Спасибо
1 ответ
Вы можете сделать последовательность последовательностей и передать их функции вызывающей стороны.
int main()
{
boost::fusion::vector<int, double> x(1, 2.5);
boost::fusion::vector<double, int> y(2, 5);
boost::fusion::vector<double, double, double> z(10, 20, 30);
CallFunc(myf(), boost::fusion::make_vector(x, y));
CallFunc(myf(), boost::fusion::make_vector(x, y, z));
}
CallFunc создает декартово произведение из элементов каждой последовательности, а затем передает их данному функтору.
#include <iostream>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/container/generation/make_vector.hpp>
#include <boost/fusion/algorithm/iteration/for_each.hpp>
#include <boost/fusion/include/empty.hpp>
#include <boost/fusion/include/pop_front.hpp>
#include <boost/fusion/include/front.hpp>
#include <boost/fusion/include/push_back.hpp>
#include <boost/fusion/include/invoke.hpp>
struct myf {
typedef void result_type;
template <class X, class Y>
void operator()(X x, Y y) {
std::cout << x + y << std::endl;
}
template <class X, class Y, class Z>
void operator()(X x, Y y, Z z) {
std::cout << x + y + z << std::endl;
}
};
template<class Stop> struct CallFuncOuter;
template<class Func, class Tail, class CallTuple>
struct CallFuncInner
{
CallFuncInner(Func &f, Tail &seq, CallTuple & args)
: f(f)
, tail(seq)
, args(args)
{
}
template<class HeadArg>
void operator()(HeadArg & head_arg) const
{
CallFuncOuter<boost::fusion::result_of::empty<Tail>::type>()
(f, tail, boost::fusion::push_back(args, head_arg));
}
Func &f;
Tail &tail;
CallTuple &args;
};
template<class Func, class Tail, class CallTuple>
CallFuncInner<Func, Tail, CallTuple> MakeCallFuncInner(Func &f, Tail &tail, CallTuple &arg)
{
return CallFuncInner<Func, Tail, CallTuple>(f, tail, arg);
}
template<class Stop>
struct CallFuncOuter
{
template<class Func, class SeqOfSeq, class CallTuple>
void operator()(Func &f, SeqOfSeq & seq, CallTuple & args) const
{
boost::fusion::for_each(boost::fusion::front(seq),
MakeCallFuncInner(
f,
boost::fusion::pop_front(seq),
args));
}
};
template<>
struct CallFuncOuter<boost::mpl::true_>
{
template<class Func, class SeqOfSeq, class CallTuple>
void operator()(Func &f, SeqOfSeq & seq, CallTuple & args) const
{
boost::fusion::invoke(f, args);
}
};
template<class Func, class SeqOfSeq>
void CallFunc(Func &f, SeqOfSeq & seq)
{
CallFuncOuter<boost::fusion::result_of::empty<SeqOfSeq>::type>()
(f, seq, boost::fusion::vector<>());
}