#include #include #include #include #include #include #include #include #include // for_each_multi template Callable for_each_multi(Tuple begins, Tuple ends, Callable fn); // visit_tuple template Callable visit_tuple(Callable fn, Head&& aTuple, Tail&& ...aTail); template struct visit_tuple_ws; // apply_tuple template void apply_tuple(Tuple&& tuple, Callable&& fn); // tuple unpack utils template struct sequence { }; template struct generate : generate { }; template struct generate<0u, S...> { typedef sequence type; }; struct Dereference { template< typename F, typename T, size_t ...S > static void apply(T&& tuple, F& fn, sequence ) { fn( *std::get(tuple) ...); } }; struct Increment { template void operator()(T&& t) { ++t; } }; struct CheckBeginEnd { CheckBeginEnd() : BeginIsNotEnd(true) {} template void operator()(T&& begin, T&& end) { BeginIsNotEnd &= (begin != end); } bool BeginIsNotEnd; }; // for_each_multi template Callable for_each_multi(Tuple begins, Tuple ends, Callable fn) { for ( ; visit_tuple(CheckBeginEnd(), begins, ends).BeginIsNotEnd; visit_tuple(Increment(), begins) ) apply_tuple(begins, fn); return fn; } template Callable for_each_multi(Callable fn, Head&& head, Tail&& ...tail) { return for_each_multi( std::make_tuple(begin(head), begin(tail)...), std::make_tuple(end(head), end(tail)...), fn); } // visit_tuple template Callable visit_tuple(Callable f, Head&& aTuple, Tail&& ...aTail) { const size_t size = std::tuple_size::type>::value-1; visit_tuple_ws::visit(f, aTuple, aTail...); return f; } template struct visit_tuple_ws { template static void visit(Callable& f, Head& aTuple, Tail& ...aTail) { visit_tuple_ws::visit(f, aTuple, aTail...); f(std::get(aTuple), std::get(aTail)...); } }; template<> struct visit_tuple_ws<0u> { template static void visit(Callable& f, Head& aTuple, Tail& ...aTail) { f(std::get<0>(aTuple), std::get<0>(aTail)...); } }; // apply_tuple template void apply_tuple(Tuple&& tuple, Callable&& fn) { const int size = std::tuple_size::type>::value; Unpacker::apply( std::forward(tuple), std::forward(fn), typename generate::type() ); } using namespace std; // support template auto begins(Head&& head, Tail&& ...tail) -> decltype(std::make_tuple(head.begin(), tail.begin()...)) { return std::make_tuple(head.begin(), tail.begin()...); } template auto ends(Head&& head, Tail&& ...tail) -> decltype(std::make_tuple(head.end(), tail.end()...)) { return std::make_tuple(head.end(), tail.end()...); } #define ON(...) begins(__VA_ARGS__), ends(__VA_ARGS__) int main() { vector vec1 {1,2,3}; list list1 {10, 20 ,30}; array arr {"one", "two", "three"}; for_each_multi(ON(vec1, list1, arr), [](int i, int l, const string& s) { cout << i << " (" << s << ")" << " * 10 is " << l << endl; }); return 0; }