C++中的函数组合

Question

有许多令人印象深刻的Boost库，如Boost.Lambda或Boost.Phoenix，它们将C++变成真正的函数式语言有很大的帮助。但是有没有一种直接的方法可以从任意两个或更多的任意函数或函子创建复合函数？

如果我有：int f(int x)和int g(int x)，我要像做f . g这将静态生成一个新的函数对象等同于f(g(x)).

这似乎是通过各种技术，如讨论here成为可能。当然，您可以将呼叫链接到boost::lambda::bind以创建复合函子。但是，有没有在升压任何事情很容易让你采取任何2个或多个函数或函数对象，并结合他们创造一个单一的复合仿函数，类似于你会怎么做它象Haskell语言？

Answer 1

我不知道任何支持当前语法的东西。但是，创建一个会很简单。简单地重写为*函子（升压::功能<>例如），使得它返回复合算符。

template < typename R1, typename R2, typename T1, typename T2 > 
boost::function<R1(T2)> operator * (boost::function<R1(T2)> const& f, boost::function<R2(T2)> const& g) 
{ 
    return boost::bind(f, boost::bind(g, _1)); 
} 

未经测试，但我怀疑它是关闭，如果它不开箱即用。

Answer 2

模板他们。

template<typename T1> class FunctorOne { 
    FunctorOne(T1 newt) 
     : t(newt) {} 
    void operator()() { 
     t(); 
    } 
    T1 t; 
}; 
template<> class FunctorOne<void> { 
    void operator()() { 
    } 
}; 
template<typename T1> class FunctorTwo { 
    FunctorOne(T1 newt) 
     : t(newt) {} 
    void operator()() { 
     t(); 
    } 
    T1 t; 
}; 
template<> class FunctorTwo<void> { 
    void operator()() { 
    } 
}; 
FunctorOne<FunctorTwo<FunctorOne<FunctorTwo<void>>>>> strangefunctionobject(FunctorTwo(FunctorOne(FunctorTwo())); 

推荐使用typedefs。
编辑：哎呦。原来，构造函数中的类型推断很糟糕。我会在一分钟之内回复一些实际工作的内容：P
更多编辑：
如果您只需要函数而不是函数，您可以创建一个新实例，甚至只需使用静态函数。

template<typename T1, typename T2> class FunctorOne { 
public: 
    static bool Call() { 
     T1::Call(T2::Call()); 
     return true; 
    } 
}; 
template<> class FunctorOne<void, void> { 
public: 
    static bool Call() { 
    } 
}; 
template<typename T1> class FunctorTwo { 
public: 
    static bool Call() { 
     T1::Call(); 
    } 
}; 
template<> class FunctorTwo<void> { 
public: 
    static bool Call() { 
    } 
}; 

bool haicakes = FunctorOne<FunctorTwo<void>, FunctorTwo<void>>::Call(); 

这假定在任何给定的函数中，您可以手动处理每个不同的签名。使用decltype可以在这方面用C++ 0x编译器。

Answer 3

在这个问题上磕磕绊绊，我想指出今天遇到这个问题的任何人，只要使用标准库和一些辅助类，就可以使用相对优雅的语法，这要归功于decltype，auto和perfect转发。

定义这两个类：

template <class Arg, class ArgCall, class OuterCall> 
class pipe { 
private: 
    ArgCall argcall; 
    OuterCall outercall; 
public: 
    typedef pipe<Arg, ArgCall, OuterCall> this_type; 
    pipe(ArgCall ac, OuterCall oc) : argcall(ac), outercall(oc) {} 
    auto operator()(Arg arg) -> decltype(outercall(argcall(arg))) { 
     return outercall(argcall(arg)); 
    } 
    template <class NewCall> 
    pipe<Arg, this_type, NewCall> operator[](NewCall&& nc) { 
     return {*this, std::forward<NewCall>(nc)}; 
    } 
}; 

template <class Arg> 
class pipe_source { 
public: 
    typedef pipe_source<Arg> this_type; 
    Arg operator()(Arg arg) { 
     return arg; 
    } 
    template <class ArgCall, class OuterCall> 
    static pipe<Arg, ArgCall, OuterCall> create(ArgCall&& ac, OuterCall&& oc) { 
     return {std::forward<ArgCall>(ac), std::forward<OuterCall>(oc)}; 
    } 
    template <class OuterCall> 
    pipe<Arg, this_type, OuterCall> operator[](OuterCall&& oc) { 
     return {*this, std::forward<OuterCall>(oc)}; 
    } 
}; 

一个简单的程序：

int f(int x) { 
     return x*x; 
} 

int g(int x) { 
     return x-2; 
} 

int h(int x) { 
     return x/2; 
} 

int main() { 
     auto foo = pipe_source<int>::create(f, g); 
     //or: 
     auto bar = pipe_source<int>()[g][h]; 
     std::cout << foo(10) << std::endl; 
     std::cout << bar(10) << std::endl; 
     return 0; 
} 

这有额外的好处，一旦它在管道，只要返回类型是正确的，你可以添加另一个功能f连接到管道[f]。

然后：

$ g++ test.cpp -o test -std=c++11 
$ ./test 
98 
4 
$ 

Answer 4

对于任何磕磕绊绊到这个网页上，有来自bureau14这一主题的精彩的博客贴子：

http://blog.quasardb.net/function-composition-in-c11/

这需要新的功能优势，在C++ 11以及使用提升。

Answer 5

看到这个答案https://stackoverflow.com/a/27727236/286335。 真的很短，简单而一般。

Answer 6

C++ 11。没有提升。没有助手类。任何数量的参数。只需std :: function和variadic模板。

template <typename F1, typename F2> 
struct function_composition_traits : public function_composition_traits<decltype(&F1::operator()), decltype(&F2::operator())> 
{}; 

template <typename ClassType1, typename ReturnType1, typename... Args1, typename ClassType2, typename ReturnType2, typename... Args2> 
struct function_composition_traits<ReturnType1(ClassType1::*)(Args1...) const, ReturnType2(ClassType2::*)(Args2...) const> 
{ 
     typedef std::function<ReturnType2(Args1...)> composition; 

     template <typename Func1, typename Func2> 
     inline static composition compose(const Func1& f1, const Func2& f2) { 
      return [f1,f2](Args1... args) -> ReturnType2 { return f2(f1(std::forward<Args1>(args)...)); }; 
     } 
}; 

template <typename F1, typename F2> 
typename function_composition_traits<F1,F2>::composition compose(const F1& lambda1,const F2& lambda2) 
{ 
     return function_composition_traits<F1,F2>::template compose<F1,F2>(lambda1, lambda2); 
} 

template <typename F, typename... Fs> 
auto compose(F f, Fs... fs) -> decltype(compose(f, compose(fs...))) 
{ 
     return compose(f, compose(std::forward<Fs>(fs)...)); 
} 

用法：

auto add = [](int x, int y){ return x+y; }; 
auto mul = [](int x){ return x*2; }; 
auto divide = [](int x) { return (double)x/3.0; }; 
auto test = compose(add, mul, divide); 

cout << "Result: " << test(2,3); 

输出：

结果：3.33333