Generalizing for_each over a tuple to accept a variable number of arguments

Question

Currently, I have:

template <unsigned I,
          unsigned N,
          typename Tuple,
          typename UnaryFunction>
struct for_;

template <unsigned N, typename Tuple, typename UnaryFunction>
struct for_<N, N, Tuple, UnaryFunction> {
  static
  void call(const Tuple&, UnaryFunction) {}
};

template <unsigned I,
          unsigned N,
          typename Tuple,
          typename UnaryFunction>
struct for_ {
  static
  void call(Tuple&& x, UnaryFunction f) {
    f(get<I>(x));
    for_<I + 1, N, Tuple, UnaryFunction>::call(std::forward<Tuple>(x), f);
  }
};

template <typename Tuple, typename UnaryFunction>
inline
void for_each(Tuple&& x, UnaryFunction f) {
  for_<0,
    tuple_size<
      typename std::remove_const<
        typename std::remove_reference<Tuple>::type
      >::type
    >::value,
    Tuple,
    UnaryFunction>::call(std::forward<Tuple>(x), f);
}

Is it possible to generalize this, probably by variadic templates, to take any number of tuple arguments?

EDIT:

Here is how I would use what I am unable to define:

if (i != e) {
  std::array<Tuple, 2> x;
  std::get<0>(x) = *i;
  std::get<1>(x) = *i;
  ++i;
  std::for_each (i, e, [&x](const Tuple& y) {
    for_each(std::get<0>(x), y, assign_if(std::less));
    for_each(std::get<1>(x), y, assign_if(std::greater));
  });
}

EDIT: changed to use rvalue references and std::forward

How does this work, considering tuples are heterogeneous, but only one `UnaryFunction` overload would be applied to every element? — Cubbi, Apr 12 '11 at 19:48
It requires that the tuple be homogeneous - I am using tuples to represent geometric points (tuple). array works as well (I believe it supports the tuple interface) - the important part is compile-time get (vs. runtime iterators). This is partly so that the uses can be generalized to other dimensions (array, etc.) without compromising compile-time checks. — ScootyPuff, Apr 12 '11 at 19:54
This is easily possible, but only if you use a proper functor vs. a lambda. C++11 lambdas are intrinsically monomorphic; consider using [boost](http://www.boost.org/).[phoenix](http://www.boost.org/doc/libs/release/libs/spirit/phoenix/doc/html/index.html) if you want efficient polymorphic lambdas. — ildjarn, Apr 13 '11 at 03:38
I was able to get it to work using map_each(UnaryFunction, Head&&, Tail&&...), and plan on submitting this after the requisite 24 hours unless someone else can present an solution with UnaryFunction as the final parameter type. — ScootyPuff, Apr 13 '11 at 13:58
@ScootyPuff: Just for your information, §14.8.2.5/10 says _A function parameter pack can only occur at the end of a parameter-declaration-list_. So, if what you need is a variadic function template, `UnaryFunction` may not be able to be the final parameter. — Ise Wisteria, Apr 13 '11 at 16:43
I used to be obsessed with C++0x. This kind of situation is why I learned Python. — Neil G, Apr 13 '11 at 20:03

score 1 · Answer 1 · answered Dec 03 '12 at 15:03

I'm not sure is it what you expected, but I'll post it - maybe someone will find it helpful.

namespace std {
    template<int I, class Tuple, typename F> struct for_each_impl {
        static void for_each(const Tuple& t, F f) {
            for_each_impl<I - 1, Tuple, F>::for_each(t, f);
            f(get<I>(t));
        }
    };
    template<class Tuple, typename F> struct for_each_impl<0, Tuple, F> {
        static void for_each(const Tuple& t, F f) {
            f(get<0>(t));
        }
    };
    template<class Tuple, typename F>
    F for_each(const Tuple& t, F f) {
        for_each_impl<tuple_size<Tuple>::value - 1, Tuple, F>::for_each(t, f);
        return f;
    }
}

Functor:

struct call_tuple_item {
    template<typename T>
    void operator()(T a) {
        std::cout << "call_tuple_item: " << a << std::endl;
    }
};

Main function:

std::tuple<float, const char*> t1(3.14, "helloworld");
std::for_each(t1, call_tuple_item());

score 0 · Answer 2 · edited May 23 '17 at 09:58

0

You can check my answer here for a hint on expanding tuples

How do I expand a tuple into variadic template function's arguments?

edited May 23 '17 at 09:58

Community

1
1

answered Apr 12 '11 at 22:19

David

3,324
2
27
31

Does tuple packing/unpacking incur any overhead? I assume for a decent compiler, no. My plan is to write a "zip"-like (hoogle zip) function to perform the zipping, then use code similar to yours to unpack and apply the function. – ScootyPuff Apr 13 '11 at 12:23
I would assume no and a good compiler will unwind and compress everything to the compact form as if you had written it manually – David Apr 14 '11 at 00:29
The only concern I have is the type of the tuple - I'm assuming I would want it to be `tuple` or similar, to ensure no copy constructors, etc. (even if the actual tuple type may not exist at runtime, I assume some objects' constructors/destructors/assignment operators may have side effects that cannot be elided). – ScootyPuff Apr 14 '11 at 13:40

score 0 · Accepted Answer · answered Apr 13 '11 at 19:45

See below for the map(UnaryFunction, Tuple&&...) implementation I will be using, as well as the code I had been messing with in an attempt to get it working completely as I wanted (for_aux, last, etc.).

#include <array>
#include <iostream>
#include <tuple>

namespace detail {

  struct static_ {
  private:
    static_() = delete;
    static_(const static_&) = delete;
    static_& operator=(const static_&) = delete;
  };

  template <unsigned... Args>
  struct max;

  template <unsigned Head, unsigned... Tail>
  struct max<Head, Tail...>: private static_ {
    static const unsigned value = Head > max<Tail...>::value
      ? Head
      : max<Tail...>::value;
  };

  template <>
  struct max<>: private static_ {
    static const unsigned value = 0;
  };

  template <unsigned... Args>
  struct min;

  template <unsigned Head, unsigned... Tail>
  struct min<Head, Tail...>: private static_ {
    static const unsigned value = Head < min<Tail...>::value
      ? Head
      : min<Tail...>::value;
  };

  template <>
  struct min<>: private static_ {
    static const unsigned value = 0;
  };

  template <typename... Args>
  struct for_aux;

  template <typename A, typename B>
  struct for_aux<A, B>: private static_ {
    static
    void call(A&& a, B b) {
      b(std::forward(a));
    }
  };

  template <typename A, typename B, typename C>
  struct for_aux<A, B, C>: private static_ {
    static
    void call(A&& a, B&& b, C c) {
      c(std::forward(a), std::forward(b));
    }
  };

  template <typename A, typename B, typename C, typename D>
  struct for_aux<A, B, C, D>: private static_ {
    static
    void call(A&& a, B&& b, C&& c, D d) {
      d(std::forward(a), std::forward(b), std::forward(c));
    }
  };

  // template <typename Head, typename... Tail>
  // struct for_aux: private static_ {
  //   static
  //   void call(Tail&&... x, Head f) {
  //     f(std::forward(x)...);
  //   }
  // };

  template <typename... Args>
  struct last;

  template <typename X>
  struct last<X>: private static_ {
    typedef X type;
  };

  template <typename Head, typename... Tail>
  struct last<Head, Tail...>: private static_ {
    typedef typename last<Tail...>::type type;
  };

  template <unsigned I,
            unsigned N,
            typename UnaryFunction,
            typename... Tuples>
  struct map;

  template <unsigned N, typename UnaryFunction, typename... Tuples>
  struct map<N, N, UnaryFunction, Tuples...>: private static_ {
    static
    void call(UnaryFunction, const Tuples&...) {}
  };

  template <unsigned I,
            unsigned N,
            typename UnaryFunction,
            typename... Tuples>
  struct map: private static_ {
    static
    void call(UnaryFunction f, Tuples&&... x) {
      f(std::get<I>(std::forward<Tuples>(x))...);
      map<I + 1,
        N,
        UnaryFunction,
        Tuples...>::call(f, std::forward<Tuples>(x)...);
    }
  };

  template <typename Tuple>
  struct tuple_size: private static_ {
    enum {
      value = std::tuple_size<
        typename std::remove_const<
          typename std::remove_reference<Tuple>::type
        >::type
      >::value
    };
  };

}

template <typename UnaryFunction, typename... Tuples>
inline
void map(UnaryFunction f, Tuples&&... x) {
  detail::map<0,
    detail::max<
      detail::tuple_size<Tuples>::value...
    >::value,
    UnaryFunction,
    Tuples...
  >::call(f, std::forward<Tuples>(x)...);
}

using namespace std;

struct f {
  template <typename T, typename U>
  void operator()(const T& i, const U& j) {
    cout << i << " " << j << endl;
  }
};

int main() {
  const array<int, 2> x = {{2}};
  const tuple<double, char> y(1.1, 'a');
  map(f(), x, y);
}

Generalizing for_each over a tuple to accept a variable number of arguments

3 Answers3