Question

我为元组找到了一个for_each循环，它只是迭代元素并将它们传递给函数。

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>
  void for_each(const Tuple& t, F f) {
    for_each_impl<tuple_size<Tuple>::value - 1, Tuple, F>::for_each(t, f);
  }
}

auto t = std::make_tuple(Foo(),Bar(),Baz());
std::for_each(t,[](???){});

是否可以拥有这样的通用函数？

std::for_each(t,[](T &&t){t.foo();});

最后，我只想拥有适合每个元组的东西。

std::get<0>(t).foo();
std::get<1>(t).foo();
std::get<2>(t).foo();
...

使用宏可能会更容易吗？

Answer 1

在c++14中，您可以使用通用lambda表达式：

for_each(t, [] (auto&& t) { std::forward<decltype(t)>(t).foo(); });

在c++11中，您可以声明自己的仿函数：

struct Lambda
{
    template <typename T>
    void operator()(T&& t) const { std::forward<T>(t).foo(); }
};

for_each(t, Lambda{});

或者，如果您希望根据当前正在处理的元组元素的类型应用不同的函数，那么再次使用自定义函子：

struct Lambda
{
    void operator()(const Foo& foo) const { foo.foo(); }
    void operator()(const Bar& bar) const { bar.bar(); }
    void operator()(const Baz& baz) const { baz.baz(); }
};

for_each(t, Lambda{});

并且作为旁注：不要在std命名空间内定义函数。

是否可以在元组元素上应用泛型函数？

1 个答案: