Call function for each tuple element on one object without recursion

Question

I have an object of class A that may be called with different types and returns changed self on each call. For purpose of this question A will do

struct A {
    A call(const int&) {
    }
    A call(const string& s) {
    }
    ////
} a;

So I have a tuple of unknown types:

std::tuple<Types...> t;

and I want to call a with each tuple element, so I want to get something like:

b = a;
b = b.call(get<0>(t));
b = b.call(get<1>(t));
b = b.call(get<2>(t));
//...

or

b = a.call(get<0>(t)).call(get<1>(t)).call(get<2>(t)...)

Order is not really important (I mean if call order is reversed of even shuffled it's OK).

I do understand that it's possible to do with recursion but it's quite ugly. Is it possible to achieve without recursion?

I wish there would be compile time loop as well as something like `compile_if( f.has_method( foo ) ) f.foo();` but unfortunately with metaprogramming in c++ we have to deal with different language. — Slava, Sep 08 '15 at 14:53
I don't think you'll find something less ugly than recursion using variadic templates in this case - Except maybe if you allow yourself some third library (e.g. `boost::fusion`). There is already a [question](http://stackoverflow.com/questions/1198260/iterate-over-tuple/23142715#23142715) closely related on SO. — Holt, Sep 08 '15 at 14:54
See: http://stackoverflow.com/questions/26902633/how-to-iterate-over-a-tuple-in-c-11 provides a for each loop which hides all the gory details. — Jonathan, Sep 08 '15 at 14:56

Jarod42 · Accepted Answer · 2018-08-08T19:02:12.203

10

You may use std::index_sequence<Is...>, something like:

namespace detail
{

    template <std::size_t...Is, typename T>
    void a_call(A& a, std::index_sequence<Is...>, const T& t)
    {
        int dummy[] = {0, ((a = a.call(std::get<Is>(t))), void(), 0)...};
        static_cast<void>(dummy); // Avoid warning for unused variable.
    }

}

template <typename ... Ts>
void a_call(A& a, const std::tuple<Ts...>& t)
{
    detail::a_call(a, std::index_sequence_for<Ts...>{}, t);
}

In C++17, Folding expression allows:

    template <std::size_t...Is, typename T>
    void a_call(A& a, std::index_sequence<Is...>, const T& t)
    {
        (static_cast<void>(a = a.call(std::get<Is>(t))), ...);
    }

or even, with std::apply:

template <typename ... Ts>
void a_call(A& a, const std::tuple<Ts...>& t)
{
    std::apply([&](const auto&... args){ (static_cast<void>(a = a.call(args)), ...); }, t);
}

edited Aug 08 '18 at 19:02

answered Sep 08 '15 at 15:23

Jarod42

203,559
14
181
302

1

isn't it UB to change `a` several times? – RiaD Sep 08 '15 at 15:31
@RiaD: We are in an initializer list which forces the evaluation from left to right. – Jarod42 Sep 08 '15 at 15:35
@Jarod42 Is there a typo in the first example you gave about folding? Which operator is it folding over? I think you're missing a comma. – Brock Hargreaves Aug 08 '18 at 17:20
@BrockHargreaves: Typo indeed, comma added. – Jarod42 Aug 08 '18 at 19:03

score 0 · Answer 2 · answered Sep 08 '15 at 14:54

0

You can use boost.fusion to iterate over tuples

http://theboostcpplibraries.com/boost.fusion

answered Sep 08 '15 at 14:54

imreal

10,178
2
32
48

1

yes, this is probably the best way unless you want to make the recursion happen manually. fusion makes it pretty easy. – Chris Beck Sep 08 '15 at 14:56

score 0 · Answer 3 · edited May 23 '17 at 12:24

With some help of "get part of std::tuple":

#include <iostream>
#include <string>
#include <algorithm>
#include <tuple>

//SEE https://stackoverflow.com/questions/8569567/get-part-of-stdtuple 
//vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

template <size_t... n>
struct ct_integers_list {
    template <size_t m>
    struct push_back
    {
        typedef ct_integers_list<n..., m> type;
    };
};

template <size_t max>
struct ct_iota_1
{
    typedef typename ct_iota_1<max - 1>::type::template push_back<max>::type type;
};

template <>
struct ct_iota_1<0>
{
    typedef ct_integers_list<> type;
};

template <size_t... indices, typename Tuple>
auto tuple_subset(const Tuple& tpl, ct_integers_list<indices...>)
-> decltype(std::make_tuple(std::get<indices>(tpl)...))
{
    return std::make_tuple(std::get<indices>(tpl)...);
    // this means:
    //   make_tuple(get<indices[0]>(tpl), get<indices[1]>(tpl), ...)
}

template <typename Head, typename... Tail>
std::tuple<Tail...> tuple_tail(const std::tuple<Head, Tail...>& tpl)
{
    return tuple_subset(tpl, typename ct_iota_1<sizeof...(Tail)>::type());
    // this means:
    //   tuple_subset<1, 2, 3, ..., sizeof...(Tail)-1>(tpl, ..)
}

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//SEE https://stackoverflow.com/questions/8569567/get-part-of-stdtuple 

struct A
{

    A call(const int&) {
        std::cout << "int" << std::endl;
        return *this;
    }

    A call(const std::string& s) {
        std::cout << "string" << std::endl;
        return *this;
    }

    template <typename T>
    A call(std::tuple<T> tpl)
    {
        return call(std::get<0>(tpl));
    }

    template <typename T, typename...Types>
    A call(std::tuple<T, Types...> tpl)
    {       
        return call(std::get<0>(tpl)).call(tuple_tail(tpl));
    }
} a;

int main()
{
    std::tuple<int, std::string, int, int, std::string> t(0, "1", 2, 3, "4");   
    A b = a.call(t);
}

Output:

int
string
int
int
string

score 0 · Answer 4 · answered Sep 08 '15 at 15:31

Use std::integer_sequence and std::make_integer_sequence as shown below:

struct A {
    A call(const int&) {
        std::cout << "Calling A::call(int)" << std::endl;
        return A{};
    }
    A call(const std::string& s) {
        std::cout << "Calling A::call(std::string)" << std::endl;
        return A{};
    }
    ////
} a;

template<typename Sequence>
struct call_helper;

template<std::size_t Current, std::size_t... Rest>
struct call_helper<std::integer_sequence<std::size_t, Current, Rest...>>
{
    template<typename Tuple, typename Result>
    static auto call(Tuple const& tup, Result&& res)
    {
        // Call the next helper with the rest sequence
        return call_helper<
            std::integer_sequence<std::size_t, Rest...>
        >::call(tup, res.call(std::get<Current>(tup)));
    }
};

template<>
struct call_helper<std::integer_sequence<std::size_t>>
{
    // End reached, just return the value
    template<typename Tuple, typename Result>
    static auto call(Tuple const&, Result&& res)
        -> std::decay_t<Result>
    {
        return std::forward<Result>(res);
    }
};

template<typename Tuple, typename Result>
auto call_all(Tuple const& tup, Result res)
{
    return call_helper<std::make_integer_sequence<
        std::size_t, std::tuple_size<Tuple>::value>
    >::call(tup, std::forward<Result>(res));
}

// Test call:
std::tuple<int, std::string, int, std::string, std::string> mytup;
call_all(mytup, a);

Demo

Call function for each tuple element on one object without recursion

4 Answers4

Linked