Templates C++；0x:在多个迭代器上应用函数

我正在尝试编写一个函数，将函数映射到多个迭代器上。大概是

template <class Fun>
fun_over_variadic_args(Fun fun) { }

template <class Fun, class First, class Rest...> 
fun_over_variadic_args(Fun fun, First& first, Rest&... rest) { 
  fun(first); 
  fun_over_variadic_args(fun, rest...);
}

namespace { 
  template <class T> struct thunk_inc { 
    decltype(T::operator++()) operator()(T& t) { return ++t; } 
  }; 
}

template <class Fun, class MainIterator, class RestOfIterators...>
std::tuple<MainIt&, RestOfIts&...> map_over_iterators(Fun fun, MainIt& it, MainIt& end, RestOfIts&... rest) {
const thunk_inc();
for (; it!=end; fun_over_variadic_args(thunk_inc, it, rest...)) {
      // Do something
    }
}

模板
fun_over_variadic_args（fun-fun）{}
模板
变量参数上的乐趣（乐趣、第一和第一、休息和…休息）{
乐趣（第一）；
乐趣超过变量（乐趣、休息…）；
}
命名空间{
模板结构thunk_公司{
decltype（T:：operator++（））operator（）（T&T）{return++T；}
}; 
}
模板
std:：tuple map_over_迭代器（Fun-Fun、MainIt和it、MainIt和end、RestOfIts和…rest）{
const thunk_公司（）；
对于（；it！=结束；乐趣超过可变参数（thunk公司，it，rest…）{
//做点什么
}
}

然后问题就出现了，Fun in Fun_over_variadic_args中的函数Fun需要模板化，这意味着它不能是lambda，也不能是会污染全局命名空间的局部函数对象

有人知道更好的解决方法吗
谢谢

编辑：请注意，我想要尽可能快的速度，因此保留内联所有函数调用可能性的解决方案将是首选

Edit2：我刚刚意识到我可以使用匿名名称空间将Fun函数的范围限制在一个文件中。我仍然很想知道一个更整洁的解决方案，如果有的话

另一种解决方案我发现，只要我将结果传递给另一个函数，我就可以将一个函数fun应用于可变参数包。所以如果我有一个函数fun，我想应用到每个参数，我可以做如下的事情

template <class... T>
void foo(T... t) { }

template <class... Arg>
void test(Arg... arg) {
  foo(fun(arg)...); // Works!
  fun(arg)...; // Doesn't work! 
}

模板
void foo（T…T）{}
模板
无效测试（Arg…Arg）{
foo（fun（arg）；//有效！
有趣（arg）.；//不起作用！
}

---

然而，对使用此选项的替代解决方案的澄清意味着fun不能返回void

好吧，鉴于您对问题的额外描述，也许像这样的变量可以：

template <typename ItHead, typename... ItTail>
void advance_iterators(ItHead & it, ItTail ...others)
{
  ++it;
  advance_iterators(others...);
}

template <typename It>
void advance_iterators(ItHead & it)
{
  ++it;
}

template <typename Fun, typename ItMain, typename ...ItOthers>
apply_helper(Fun & f, ItMain it, ItOthers ...others)
{
   f(*it);
   apply_helper(f, others...);
}

template <typename Fun, typename ItMain, typename ...ItOthers>
apply_helper(Fun & f, ItMain it)
{
   f(*it);
}

template <typename Fun, typename ItMain, typename ...ItOthers>
apply (Fun & f, ItMain begin, ItMain end, ItOthers ...others)
{
  while (begin != end)
  {
    apply_helper(f, begin, others...);
    advance_iterators(begin, others...);
  }
}

模板
void advance_迭代器（ItHead&it、iTail……其他）
{
++它；
高级迭代器（其他…）；
}
模板
无效高级迭代器（ItHead&it）
{
++它；
}
模板
apply_helper（趣味与功能、it主功能、it其他功能……其他功能）
{
f（*it）；
应用辅助工具（f、其他…）；
}
模板
apply_helper（趣味与功能、it）
{
f（*it）；
}
模板
应用（乐趣和功能、ItMain开始、ItMain结束、ItOthers…其他）
{
while（开始！=结束）
{
应用辅助工具（f、begin、其他…）；
高级迭代器（begin，其他…）；
}
}

这里的明显限制是

Fun

必须处理迭代器的所有值类型，并且范围必须相等。函数对象是通过引用传递的，您可以根据需要修改它

---

更新：如果我误解了，您希望

f

同时对所有值进行操作，那么您应该摆脱

apply\u helper

，只需调用

f（begin，others…

，并创建一个函数

f

，该函数包含所有迭代器。

您能举一个例子说明如何使用它吗，或者更好地说你想达到什么目的？@Kerrek SB:fun\u over\u variadic\u args的特定解决方案将用于map\u over\u迭代器。一般来说它可以在任何需要对多个指定为可变参数的值应用函数的地方使用。@Sid:您介意制作一个最小的示例来说明此对象的实际用途吗？@Kerrek SB:为map\u over\u迭代器编写了代码，该代码演示了fun\u over\u variadic\u arg的用法，说明这可能是用+，在C++03中实现。