C++11 中是否可以将函数组合成一个新函数？

这更多的是一种理论问题。 C++11 中是否可以将函数组合成一个新函数？例如 ：

auto f = [](int i){return i * 2;};
auto g = [](int i){return i + 10;};

所以这有效：

auto c = f(g(20)); // = 60

但我想要一个存储组合的对象，比如

auto c = f(g);
std::cout << c(20) << std::endl; //prints 60

Edit:另外我想创建的是一个函数 a，你可以给它一个函数 b 和一个int n，并返回给定函数 b 的第 n 个组合。例如（不可编译）

template<typename T>
auto combine(T b, int i) -> decltype(T)
{
   if (i == 0)
      return b;

   return combine(b, i - 1);      
}

auto c = combine(f, 2); //c = f(f(f(int)))

第一次尝试：

template<class First, class Second>
auto compose( Second&& second, First&& first ) }
  return [second = std::forward<Second>(second), first=std::forward<First>(first)]
  (auto&&...args)->decltype(auto) {
    return second( first( decltype(args)(args)... ) );
  };
}
template<class A, class B, class...Rest>
auto compose(A&& a, B&& b, Rest&&... rest) {
  return compose( compose(std::forward<A>(a), std::forward<B>(b)), std::forward<Rest>(rest)... );
}
template<class A>
std::decay_t<A> compose(A&& a) {
  return std::forward<A>(a);
}

在 C++14 中。现在，这并不完美，因为该模式在 C++ 中运行得不太好。

为了完美地做到这一点，我们必须了解组合编程。在这里，函数与抽象的参数堆栈交互。每个函数都会从堆栈中弹出一些参数，然后再将一些参数弹出。

这将允许您执行以下操作：

compose( print_coord, get_x, get_y )

where get_x and get_y除了返回坐标之外什么也不消耗，并且print_coord获取两个坐标并打印它们。

为了在 C++ 中模拟这一点，我们需要一些奇特的机制。函数将返回tuples（或类似元组？），这些值将逻辑上“推入参数堆栈”。

函数也会消耗这个参数堆栈中的东西。

在每次调用时，我们解压当前的参数元组，找到可以调用该函数的最长集合，调用它，获取其返回值，如果它是元组，则将其解压，然后将任何此类返回值粘回参数堆栈。

对于这个更高级的compose要与自身组合，它需要 SFINAE 检查，并且它需要能够获取一个可调用对象和一个参数元组，并找到正确数量的参数来调用可调用对象，加上剩余的参数。

这是一个棘手的元编程，我在这里不会做。

第二部分，因为我第一次错过了，看起来像：

template<class F>
auto function_to_the_power( F&& f, unsigned count ) {
  return [f=std::forward<F>(f),count](auto&& x)
    -> std::decay_t< decltype( f(decltype(x)(x)) ) >
  {
    if (count == 0) return decltype(x)(x);
    auto r = f(decltype(x)(x));
    for (unsigned i = 1; i < count; ++i) {
      r = f( std::move(r) );
    }
    return r;
  };
}

这不使用类型擦除。

测试代码：

auto f = [](int x){ return x*3; };
auto fs = std::make_tuple(
    function_to_the_power( f, 0 ),
    function_to_the_power( f, 1 ),
    function_to_the_power( f, 2 ),
    function_to_the_power( f, 3 )
);

std::cout << std::get<0>(fs)(2) << "\n";    
std::cout << std::get<1>(fs)(2) << "\n";    
std::cout << std::get<2>(fs)(2) << "\n";    
std::cout << std::get<3>(fs)(2) << "\n";    

prints:

2
6
18
54