How to iterate over a TR1 tuple

Question

Being stuck in TR1 land, for a test program I need to perform certain operations on a number of objects of specific types. I have a couple of tuple type definitions which look like this:

typedef std::tr1::tuple< bool
                       , signed char
                       , signed short
                       , signed int
                       , signed long long
                       , unsigned char
                       , unsigned short
                       , unsigned int
                       , unsigned long long >  integral_types;

From each tuple type an object is to be created. I then have function templates similar to this:

template<typename T>
void invoke_operation_1(T& obj);

These need to be called for all objects in a tuple object.

How do I do that in C++03?

[What have you tried so far?](http://mattgemmell.com/2008/12/08/what-have-you-tried/) — Lightness Races in Orbit, May 03 '13 at 14:01
The [Boost.Fusion approach](http://stackoverflow.com/a/1201902/560648) should be C++03-compatible. A [manual approach](http://stackoverflow.com/a/1198432/560648) is here. — Lightness Races in Orbit, May 03 '13 at 14:03
@sbi: Who said anything about homework? SO questions are expected to demonstrate prior research. :) Your urgency is not relevant... — Lightness Races in Orbit, May 03 '13 at 14:03
possible duplicate of [iterate over tuple](http://stackoverflow.com/questions/1198260/iterate-over-tuple) — Luc Touraille, May 03 '13 at 14:17
Oops, I noticed that your question specifically asks about C++03: nevermind the close vote. The two questions could (should?) probably be merged in a single one, though. — Luc Touraille, May 03 '13 at 14:19
@LucTouraille yes, the C++03/C++11 question duplicity is seen often these days. Just flagged it for the mods to merge the two questions — Arne Mertz, May 03 '13 at 14:48

Puppy · Answer 1 · 2013-05-03T14:11:25.077

8

There was a feature just finalized in Bristol for C++14 to address this very problem. It's not too hard to deal with.

For the simpler case, you can use a recursive template. It's a smidge of a mess though without partial function specialization and such.

template<typename Tup, std::size_t N> struct visit_detail {
     template<typename F> static void call(Tup& t, F f) {
         f(std::tr1::get<N>(t));
         return visit_detail<Tup, N+1>::call(t, f);
     }
};
template<typename Tup> struct visit_detail<Tup, std::tr1::tuple_size<Tup>::value> {
    template<typename F> static void call(Tup& t, F f) {}
}

template<typename Tup, typename F> void visit(Tup& t, F f) {
    return visit_detail<Tup, 0>::call(t, f);
}

Here f can be hardcoded or a parameter function object or whatever you want.

edited May 03 '13 at 14:11

answered May 03 '13 at 14:06

Puppy

144,682
38
256
465

Ah, so there is indeed a `tuple_size`. Thanks, I think I can work it out from there! – sbi May 03 '13 at 14:07
@DeadMG: Yikes! Can you remember the name of the C++14 feature, for reference? – Lightness Races in Orbit May 03 '13 at 14:08
[N3493](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3493.html) slightly revised – Puppy May 03 '13 at 14:10
@DeadMG: Thanks; looks interesting (hope they don't retain the text 'compile-time' in the final wording, though!) – Lightness Races in Orbit May 03 '13 at 14:14

score 3 · Accepted Answer · answered May 03 '13 at 14:21

3

You could use boost::fusion if you need to call the same templated function for every object in the tuple. E.g.

template<typename T>
void invoke_operation_1(T& obj)
{
    std::cout << obj << std::endl;
}

struct executor
{
    template<typename T>
    void operator()(T& t) const
    {
        invoke_operation_1(t);
    }
};

typedef boost::tuple< bool
                       , signed char
                       , signed short
                       , signed int
                       , signed long long
                       , unsigned char
                       , unsigned short
                       , unsigned int
                       , unsigned long long >  integral_types;
int main()
{
    integral_types t(true, 0, 1, 2, 3, 4, 5, 6, 7);
    boost::fusion::for_each(t, executor());
    return 0;
}

answered May 03 '13 at 14:21

mkaes

13,781
10
52
72

I was hesitant to bring in boost::fusion just to do that, but this looks really convenient, so I might give it a try anyway. What conditions must `executor` meet? Would some `std::tr1::bind()` expression work instead? With argument placeholders? – sbi May 03 '13 at 14:26
@sbi The docuentation says a `Regular Callable Object` so a bind expression should ok. – mkaes May 03 '13 at 14:32
@sbi since `invoke_operation_1` is a template and not a function, I doubt `boost::bind` will work. At least I could not find any overloads taking template template arguments, which would be needed here. – Arne Mertz May 03 '13 at 14:38
@ArneMertz: You got a point there, I just ran into this. `:)` Well, then I'll just have to wrap it into a function object, I think. Thanks, @mkaes! – sbi May 03 '13 at 14:41
Well, since in the end I did indeed use fusion, I accepted this answer. Thanks to everyone who put effort into this! – sbi May 03 '13 at 15:20

score 0 · Answer 3 · answered Apr 02 '16 at 16:42

template<typename tup, typename N>
struct visit_detailImpl {
    template<typename f>
    static void call(tup& t, f f) {
        f(std::tr1::get<N::value>(t));
        return visit_detailImpl<tup, std::integral_constant<std::size_t, N::value + 1> >::call(t, f);
    }
};
template<typename tup> // end recursion struct
struct visit_detailImpl<tup, std::integral_constant<std::size_t, std::tr1::tuple_size<tup>::value> > {
    template<typename f>
    static void call(tup& t, f f) {}
};
template<typename tup, typename Fn>
void for_each_tup(tup& t, Fn f) {
    return visit_detailImpl<tup, std::integral_constant<std::size_t, 0> >::call(t, f);
}

How to iterate over a TR1 tuple

3 Answers3