Question

有许多令人印象深刻的Boost库，如Boost.Lambda或Boost.Phoenix，它们使C ++成为一种真正的功能语言。但有没有一种直接的方法可以从任何2个或更多任意函数或函子创建复合函数？

如果我有：int f(int x)和int g(int x)，我想做f . g之类的事情，它会静态生成一个等同于f(g(x)).的新函数对象

这似乎可以通过各种技术实现，例如here所讨论的那些技术。当然，您可以将调用链接到boost::lambda::bind以创建复合仿函数。但Boost中是否有任何东西可以轻松地将任何2个或更多函数或函数对象组合起来并组合起来创建一个复合函子，类似于你在Haskell这样的语言中的表达方式？

Answer 1

对于任何绊到这个页面的人来说，有一个关于这个主题的博客文章来自第14局：

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

这利用了C ++ 11中的新功能以及使用boost。

Answer 2

这个问题磕磕绊绊，我想指出今天遇到这个问题的人，只需使用标准库和一些帮助类就可以通过相对优雅的语法实现这一点，这要归功于decltype，auto和完美转发

定义这两个类：

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 3

我不知道任何支持您目前所需语法的内容。但是，创建一个是一件简单的事情。只需覆盖*为仿函数（例如boost :: function＆lt;＆gt;），以便它返回一个复合仿函数。


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 4

模板化。

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()));

建议使用typedef 编辑：哎呀。事实证明，构造函数中的类型推断很糟糕。我会在一分钟内找到实际有用的东西：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 5

请参阅此回答https://stackoverflow.com/a/27727236/286335。真的很短，容易和一般。

Answer 6

C ++ 11。没有提升。没有帮助类。任何数量的论点。只是std :: function和variadic templates。

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

C ++中的函数组合

6 个答案: