在元组上通用化for_each以接受可变数量的参数

问题描述

|| 目前，我有：

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

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

template <unsigned I,typename UnaryFunction>
struct for_ {
  static
  void call(Tuple&& x,UnaryFunction f) {
    f(get<I>(x));
    for_<I + 1,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,f);
}

是否可以通过可变参数模板将其概括为采用任意数量的元组参数？ 编辑： 这是我将无法使用的方式：

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),assign_if(std::greater));
  });
}

编辑：更改为使用右值引用和std :: forward     

解决方法

我不确定这是否是您的期望，但我会发布它-也许有人会觉得有用。

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,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,f);
        return f;
    }
}

函子：

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

主功能：

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

    ,您可以在此处查看我的答案以获取有关扩展元组的提示 如何将元组扩展为可变参数模板函数的参数？     ,请参阅以下有关我将使用的

map(UnaryFunction,Tuple&&...)

实现以及我一直在使用的代码，以使它完全按我的意愿工作（

for_aux

，

last

等）。

#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 C,typename D>
  struct for_aux<A,C,D>: private static_ {
    static
    void call(A&& a,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... Tuples>
  struct map<N,N,UnaryFunction,Tuples...>: private static_ {
    static
    void call(UnaryFunction,const Tuples&...) {}
  };

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