C++ Currying / Partial Application：函数式编程在 C++ 的应用

好的，各位朋友，大家好！今天咱们来聊聊一个听起来挺高大上，但实际上贼有意思的玩意儿：C++ 中的 Currying 和 Partial Application。别害怕，名字唬人，理解起来简单得很！咱们争取用最接地气的方式，把这个函数式编程的概念给搞明白，让你的 C++ 代码也能骚起来！

第一章：啥是 Currying 和 Partial Application？

先别急着 Google，咱们先用人话解释一下。

Currying (柯里化)： 想象一下，你有个万能酱料配方，需要蒜、醋、糖、盐等等。Currying 就是把这个配方的应用过程拆成好几步。你先给了蒜，得到一个“加了蒜的酱料配方”；再给醋，得到一个“加了蒜和醋的酱料配方”… 每次只给一部分参数，直到所有参数都给完，才能得到最终的酱料。简单来说，Currying 就是把一个多参数函数变成一系列单参数函数。
Partial Application (偏函数应用)： 这个更简单。还是酱料配方，你直接把蒜、醋、糖这三样给定了，剩下的盐让别人加。也就是说，你固定了函数的部分参数，得到一个参数更少的新函数。

区别？Currying 是把多参数函数分解成一系列单参数函数。Partial Application 是固定函数的部分参数，得到一个参数更少的新函数。可以这样理解：Currying 是 Partial Application 的一种特殊情况，每次只固定一个参数。

第二章：为什么要用它们？好处是啥？

可能有人要问了：“我好好的函数写着，干嘛要这么折腾？” 好问题！Currying 和 Partial Application 能带来不少好处：

代码复用： 比如，你有个计算器函数，calculate(operation, num1, num2)。如果经常要进行加法运算，你可以用 Partial Application 固定 operation 为 add，得到一个专门做加法的函数 add_function = partial_apply(calculate, add)。以后直接用 add_function(num1, num2) 就行了，省事！
延迟执行： 有时候，你可能只需要先准备好一些参数，等以后再真正执行函数。Currying 和 Partial Application 可以让你先把参数“存起来”，需要的时候再把剩下的参数补全，执行函数。
代码更清晰： 特别是在处理事件处理、回调函数等场景，用 Currying 和 Partial Application 可以让代码逻辑更清晰，更容易理解。
函数组合: 函数式编程中，函数组合是一个非常重要的概念。 Currying 和 Partial Application 可以更容易地进行函数组合，构建更复杂的功能。

第三章：C++ 怎么实现 Currying 和 Partial Application？

C++ 本身没有内置的 Currying 和 Partial Application 功能，但我们可以用一些技巧来实现。主要手段包括：

Lambda 表达式： Lambda 表达式是 C++11 引入的，它允许我们定义匿名函数。这玩意儿是实现 Currying 和 Partial Application 的利器。
std::bind： std::bind 可以绑定函数的部分参数，返回一个函数对象。
函数对象（Functors）： 可以定义一个类，重载 operator()，使类的对象可以像函数一样被调用。

咱们一个个来看：

1. Lambda 表达式实现 Currying

#include <iostream>
#include <functional>

// 一个简单的加法函数
auto add = [](int x, int y) {
    return x + y;
};

// Currying 后的加法函数
auto curried_add = [](int x) {
    return [x](int y) {
        return x + y;
    };
};

int main() {
    // 普通加法
    std::cout << "普通加法: " << add(5, 3) << std::endl;

    // Currying 后的加法
    auto add_5 = curried_add(5); // 返回一个接受一个参数的函数
    std::cout << "Currying 加法: " << add_5(3) << std::endl; // 相当于 add(5, 3)

    return 0;
}

解释：

add 是一个普通的 Lambda 表达式，接受两个 int 参数，返回它们的和。
curried_add 是 Currying 后的 Lambda 表达式。它接受一个 int 参数 x，返回另一个 Lambda 表达式。这个返回的 Lambda 表达式接受一个 int 参数 y，并返回 x + y。

更通用一点的 Currying 函数模板:

template <typename Func>
auto curry(Func func) {
    return [func](auto x) {
        return [func, x](auto y) {
            return func(x, y);
        };
    };
}

int main() {
    auto curried_add = curry(add);
    auto add_5 = curried_add(5);
    std::cout << "通用 Currying 加法: " << add_5(3) << std::endl;

    return 0;
}

这个模板 curry 接受一个函数 func 作为参数，返回一个 Currying 后的函数。这个版本只支持两个参数的函数，但是可以扩展到支持更多参数。

2. Lambda 表达式实现 Partial Application

#include <iostream>
#include <functional>

// 一个简单的乘法函数
auto multiply = [](int x, int y, int z) {
    return x * y * z;
};

// Partial Application 后的乘法函数
auto partial_multiply = [](int x, int y) {
    return [x, y](int z) {
        return multiply(x, y, z);
    };
};

int main() {
    // 普通乘法
    std::cout << "普通乘法: " << multiply(2, 3, 4) << std::endl;

    // Partial Application 后的乘法
    auto multiply_2_3 = partial_multiply(2, 3); // 返回一个接受一个参数的函数
    std::cout << "Partial Application 乘法: " << multiply_2_3(4) << std::endl; // 相当于 multiply(2, 3, 4)

    return 0;
}

解释：

multiply 是一个普通的 Lambda 表达式，接受三个 int 参数，返回它们的积。
partial_multiply 是 Partial Application 后的 Lambda 表达式。它接受两个 int 参数 x 和 y，返回另一个 Lambda 表达式。这个返回的 Lambda 表达式接受一个 int 参数 z，并返回 multiply(x, y, z)。

更通用一点的 Partial Application 函数模板:

template <typename Func, typename... Args>
auto partial_apply(Func func, Args... args) {
    return [func, args...](auto... remaining_args) {
        return func(args..., remaining_args...);
    };
}

int main() {
    auto multiply_2_3 = partial_apply(multiply, 2, 3);
    std::cout << "通用 Partial Application 乘法: " << multiply_2_3(4) << std::endl;

    return 0;
}

这个模板 partial_apply 接受一个函数 func 和任意数量的参数 args... 作为参数，返回一个 Partial Application 后的函数。这个版本使用了可变参数模板，可以支持任意数量的参数。

3. std::bind 实现 Partial Application

#include <iostream>
#include <functional>

// 一个简单的除法函数
double divide(double x, double y) {
    if (y == 0) {
        throw std::runtime_error("除数不能为 0!");
    }
    return x / y;
}

int main() {
    // 使用 std::bind 进行 Partial Application
    auto divide_by_2 = std::bind(divide, std::placeholders::_1, 2.0); // 固定第二个参数为 2.0

    std::cout << "Partial Application 除法: " << divide_by_2(10.0) << std::endl; // 相当于 divide(10.0, 2.0)

    return 0;
}

解释：

std::bind 接受一个函数和一些参数作为参数。
std::placeholders::_1 是一个占位符，表示第一个参数。在这个例子中，我们固定了 divide 函数的第二个参数为 2.0，第一个参数使用占位符。
divide_by_2 是一个函数对象，它接受一个 double 参数，并返回 divide(x, 2.0) 的结果。

4. 函数对象（Functors）实现 Currying 和 Partial Application

#include <iostream>
#include <functional>

// 函数对象实现 Currying
class Adder {
private:
    int x;

public:
    Adder(int x) : x(x) {}

    int operator()(int y) {
        return x + y;
    }
};

// 函数对象实现 Partial Application
class Multiplier {
private:
    int x;
    int y;

public:
    Multiplier(int x, int y) : x(x), y(y) {}

    int operator()(int z) {
        return x * y * z;
    }
};

int main() {
    // Currying 使用函数对象
    Adder add_5(5);
    std::cout << "函数对象 Currying 加法: " << add_5(3) << std::endl;

    // Partial Application 使用函数对象
    Multiplier multiply_2_3(2, 3);
    std::cout << "函数对象 Partial Application 乘法: " << multiply_2_3(4) << std::endl;

    return 0;
}

解释：

Adder 是一个函数对象，它接受一个 int 参数 x 作为构造函数的参数，并重载了 operator()。operator() 接受一个 int 参数 y，并返回 x + y。
Multiplier 是一个函数对象，它接受两个 int 参数 x 和 y 作为构造函数的参数，并重载了 operator()。operator() 接受一个 int 参数 z，并返回 x * y * z。

第四章：实战案例：事件处理

咱们来个稍微复杂点的例子，看看 Currying 和 Partial Application 在事件处理中的应用。

假设你有个按钮类 Button，它有个 onClick 事件，当按钮被点击时，会调用绑定的回调函数。

#include <iostream>
#include <functional>
#include <vector>

class Button {
public:
    using Callback = std::function<void()>;

    void setOnClick(Callback callback) {
        onClickCallback = callback;
    }

    void click() {
        if (onClickCallback) {
            onClickCallback();
        }
    }

private:
    Callback onClickCallback;
};

// 一个简单的日志函数
void logMessage(const std::string& message) {
    std::cout << "日志: " << message << std::endl;
}

int main() {
    Button button;

    // 使用 Partial Application 绑定事件处理函数
    auto log_button_click = std::bind(logMessage, "按钮被点击了!");
    button.setOnClick(log_button_click);

    button.click(); // 触发事件，输出 "日志: 按钮被点击了!"

    // 也可以使用 Lambda 表达式
    button.setOnClick([]() { logMessage("Lambda 按钮点击!"); });
    button.click();

    return 0;
}

解释：

logMessage 是一个简单的日志函数，接受一个字符串参数，并输出到控制台。
std::bind(logMessage, "按钮被点击了!") 使用 Partial Application 将 logMessage 函数的参数固定为 "按钮被点击了!"，返回一个无参数的函数对象。
button.setOnClick(log_button_click) 将这个函数对象绑定到按钮的 onClick 事件上。
当按钮被点击时，log_button_click 函数对象会被调用，从而输出日志信息。

第五章：总结与注意事项

Currying 和 Partial Application 是函数式编程中非常有用的概念，可以提高代码的复用性、灵活性和可读性。

适用场景： 它们特别适合于需要延迟执行、代码复用、函数组合的场景，比如事件处理、回调函数、配置参数等。
C++ 实现： C++ 可以通过 Lambda 表达式、std::bind、函数对象等方式来实现 Currying 和 Partial Application。
注意事项： 不要过度使用！如果你的代码本来就很简单，就没必要为了用而用。滥用 Currying 和 Partial Application 反而会让代码更难理解。
模板元编程： 如果对性能有极致要求，并且需要支持任意参数数量的 Currying，可以考虑使用模板元编程来实现，但是代码会变得非常复杂。
与其他函数式编程概念结合： Currying 和 Partial Application 通常与函数组合、高阶函数等概念一起使用，可以构建更强大的函数式编程应用。

希望通过今天的讲解，大家对 C++ 中的 Currying 和 Partial Application 有了更深入的了解。记住，编程的本质是解决问题，选择最适合你的工具，让你的代码更优雅、更高效！下次有机会，再和大家聊聊函数组合和高阶函数。拜拜！

发表回复 取消回复

发表回复取消回复