第25章柯里化与部分应用

课程目录第25章柯里化与部分应用

柯里化与部分应用：手动实现柯里化、std::bind与柯里化

好，咱们今天聊聊柯里化和部分应用。这两个概念，说白了就是「怎么把一个多参数的函数，拆成一系列单参数函数的链式调用」。嗯，听起来有点绕，但实际用起来非常顺手。

我记得刚接触函数式编程那会儿，看到柯里化这个词，第一反应是「这又是哪个数学家搞出来的抽象概念？」后来在项目中真正用上了，才发现它其实特别接地气。

什么是柯里化？

柯里化（Currying）是把一个接受多个参数的函数，转换成一系列接受单个参数的函数。每次调用返回一个新函数，直到所有参数都凑齐了，才真正执行。

举个例子，你有一个加法函数：

// 普通版本
int add(int a, int b, int c) {
    return a + b + c;
}

// 柯里化版本
auto curried_add = [](int a) {
    return [a](int b) {
        return [a, b](int c) {
            return a + b + c;
        };
    };
};

// 使用
auto result = curried_add(1)(2)(3); // 6

你看，每次只传一个参数，返回一个捕获了前面参数的新 lambda。这就是柯里化的核心思想。

核心要点：柯里化不是减少参数数量，而是把多参数函数拆成单参数函数的链。每个中间函数都「记住」了之前传入的参数。

手动实现柯里化

在 C++ 里手动实现柯里化，其实就是在玩模板和 lambda 的嵌套。我给大家写一个通用的柯里化工具：

#include <functional>
#include <type_traits>

// 基础版本：二元函数柯里化
template <typename F, typename T>
auto curry(F f, T t) {
    return [f, t](auto... args) {
        return f(t, args...);
    };
}

// 递归版本：支持任意参数个数
template <typename F>
auto curry(F f) {
    return f;  // 零参数或已柯里化
}

template <typename F, typename T, typename... Args>
auto curry(F f, T t, Args... args) {
    auto partial = [f, t](auto... rest) {
        return f(t, rest...);
    };
    return curry(partial, args...);
}

嗯，这里要注意，上面的递归版本其实是在做「部分应用」，不是严格意义上的柯里化。严格柯里化应该每次只绑定一个参数：

// 严格柯里化：每次只绑定一个参数
template <typename F, typename T>
auto curry_one(F f, T t) {
    return [f, t](auto... args) {
        return f(t, args...);
    };
}

// 使用示例
auto add = [](int a, int b, int c) { return a + b + c; };
auto curried = curry_one(curry_one(add, 1), 2);
auto result = curried(3); // 6

我的经验：在实际项目中，我很少用严格柯里化。因为每次只传一个参数，调用链太长，代码可读性反而下降。我更常用的是「部分应用」——一次绑定多个参数，留一两个参数后面再传。

std::bind 与柯里化

C++11 引入的 std::bind，本质上就是一个部分应用工具。它可以把一个函数的某些参数固定下来，生成一个新的可调用对象。

#include <functional>

void print_sum(int a, int b, int c) {
    std::cout << a + b + c << std::endl;
}

int main() {
    // 绑定前两个参数
    auto bound = std::bind(print_sum, 10, 20, std::placeholders::_1);
    bound(30); // 输出 60

    // 绑定第一个和第三个参数
    auto bound2 = std::bind(print_sum, 100, std::placeholders::_1, 300);
    bound2(200); // 输出 600

    return 0;
}

你看，std::bind 用 std::placeholders::_1、_2 这些占位符，表示「这个参数我还没定，后面再传」。说白了，这就是部分应用的标准实现。

我曾经踩过的坑：用 std::bind 绑定成员函数时，第一个参数必须是对象指针或智能指针。如果你传了一个临时对象，函数执行时对象已经销毁了，那就是未定义行为。我曾经因为这个 bug 查了一下午。

std::bind 与 lambda 的对比

很多人问我：「有了 lambda，还要 std::bind 干嘛？」我的回答是：std::bind 在某些场景下更简洁，但 lambda 更灵活、更安全。

特性	std::bind	lambda
参数绑定	支持占位符，灵活绑定任意位置	需要手动捕获，位置固定
可读性	占位符多了容易混乱	代码直观，一目了然
性能	可能产生额外开销	编译器优化更好
调试难度	错误信息晦涩	错误信息清晰
适用场景	与旧代码兼容、重载函数	新代码首选

我个人习惯是：新代码一律用 lambda，除非要跟旧 API 对接，或者需要处理函数重载的情况。你想想看，lambda 的捕获列表清清楚楚，而 std::bind 的占位符多了，连自己都看不懂。

实战：用柯里化思想简化回调

我在做一个网络库的时候，遇到过这样的场景：一个回调函数需要携带上下文信息。用柯里化的思想，可以优雅地解决：

// 原始回调：需要三个参数
void on_data_received(int socket_id, const char* data, size_t len);

// 使用柯里化/部分应用，提前绑定 socket_id
auto create_handler = [](int socket_id) {
    return [socket_id](const char* data, size_t len) {
        on_data_received(socket_id, data, len);
    };
};

// 注册回调时，只需要传 data 和 len
auto handler = create_handler(42);
register_callback(handler);

你看，这样就把「谁在回调」和「回调内容」分开了。代码更清晰，也更容易测试。

柯里化的局限性

说实话，C++ 的柯里化不像 Haskell 那样原生支持。手动实现起来，模板代码会比较多。而且 C++ 的 lambda 捕获是值捕获或引用捕获，没有 Haskell 那种「惰性求值」的特性。

但是，这并不妨碍我们在合适的场景下使用它。我建议你记住两点：

部分应用比严格柯里化更实用：一次绑定多个参数，留一两个灵活参数
lambda 优先于 std::bind：除非有特殊需求，否则 lambda 更安全、更易读

总结一下：柯里化和部分应用，本质上是「延迟执行」和「参数复用」的技巧。它们让代码更灵活，但也要注意不要过度使用，否则反而降低可读性。

好了，关于柯里化和部分应用，咱们就聊到这儿。记住核心思想：把多参数函数拆成单参数链，或者提前绑定一部分参数。这两种技巧，在实际项目中能帮你写出更灵活、更可复用的代码。

📚 课程目录

柯里化与部分应用：手动实现柯里化、std::bind与柯里化

什么是柯里化？

手动实现柯里化

std::bind 与柯里化

std::bind 与 lambda 的对比

实战：用柯里化思想简化回调

柯里化的局限性