C++中如何用高阶函数实现函数的线性组合？

现有如下代码片段：

// 若干函数
double f1( double x );
double f2( double x );
double f3( double x );
// 系数
double c1, c2, c3;
// 输入变量
double x;

需要计算公式：y = c₁f₁(x) + c₂f₂(x) + c₃f₃(x)

直接实现方式为：

double y = c1*f1(x) + c2*f2(x) + c3*f3(x);  // x作为参数被传递3次

但我们需要以**函子（高阶函数）**的方式实现，核心是对函数而非数值执行算术运算，且仅传递一次x参数，伪代码示例如下：

auto F = c1*f1 + c2*f2 + c3*f3; // 生成组合后的函子
double y = F(x);                // 仅传递一次x值

请问能否通过C++标准库或Boost库（如Boost.HOF）实现该需求？或是否有其他适用的第三方库？代码无需完全与示例一致，核心逻辑满足即可。

1. C++标准库原生实现 #

可以通过自定义模板函子类，重载乘法（绑定系数与函数）和加法（组合函子）运算符来实现，无需依赖第三方库：

#include <functional>

// 封装函数与缩放系数的模板函子
template<typename Func>
class ScaledFunction {
private:
    Func func_;
    double scale_;
public:
    ScaledFunction(Func func, double scale) 
        : func_(std::move(func)), scale_(scale) {}

    // 调用函子，计算缩放后的函数值
    double operator()(double x) const {
        return scale_ * func_(x);
    }

    // 重载加法，组合两个ScaledFunction
    template<typename OtherFunc>
    auto operator+(const ScaledFunction<OtherFunc>& other) const {
        return ScaledFunction(
            [this, &other](double x) { return (*this)(x) + other(x); },
            1.0
        );
    }
};

// 辅助函数，简化ScaledFunction实例的创建
template<typename Func>
auto scale(Func func, double coeff) {
    return ScaledFunction<Func>(std::move(func), coeff);
}

// 使用示例
int main() {
    // 假设f1、f2、f3已定义，c1、c2、c3、x已赋值
    auto combined = scale(f1, c1) + scale(f2, c2) + scale(f3, c3);
    double y = combined(x); // x仅传递一次
    return 0;
}

该方案通过自定义模板类实现函数与系数的绑定，重载加法运算符实现函子组合，最终生成的组合函子只需接收一次x参数即可完成全部计算。

2. Boost.HOF库实现 #

Boost.HOF提供了丰富的高阶函数工具，能更简洁地实现函数组合：

#include <boost/hof.hpp>

int main() {
    // 定义系数缩放函数：将系数与目标函数绑定
    auto scale = [](double coeff, auto func) {
        return boost::hof::compose(
            [coeff](double val) { return coeff * val; },
            func
        );
    };

    // 用boost::hof::plus组合多个缩放后的函数
    auto combined = boost::hof::plus(
        scale(c1, f1),
        boost::hof::plus(scale(c2, f2), scale(c3, f3))
    );

    double y = combined(x); // x仅传递一次
    return 0;
}

也可以利用Boost.HOF的lift和占位符进一步简化语法，直接表达线性组合逻辑：

#include <boost/hof.hpp>

using namespace boost::hof;

int main() {
    // 直接构造组合函子
    auto combined = lift(_1 * f1(_2) + _2 * f2(_2) + _3 * f3(_2))(c1, c2, c3);
    double y = combined(x);
    return 0;
}

Boost.HOF的优势在于无需手动编写大量模板代码，依赖库中现成的高阶函数工具，代码更简洁直观。

3. 其他适用第三方库 #

• Eigen库：虽主打线性代数，但支持表达式模板，可将可调用对象视为"函数项"进行线性组合，适合复杂多函数的组合场景。
• Range-v3库：提供函数式编程扩展，通过view::transform等工具可实现类似的函数组合逻辑，风格偏向数据流处理。

内容的提问来源于stack exchange，提问作者soad