C++ 里面散发的咖喱味儿 - Currying函数式编程

时间：2024-11-15 22:11:36

C++ 里面散发的咖喱味儿 - Currying函数式编程

大家好，最近几篇都在聊C++里面的函数式编程，今天我们继续就某一个点来深入聊一下，来聊聊在 C++ 中如何使用 std::bind 来实现函数式编程，尤其是柯里化（Currying）这个概念。如果你对 JavaScript 里的柯里化已经有所了解，那就更好了，我们会引用一些 JavaScript 的例子来帮助理解。

c++-currying

什么是柯里化（Currying）

柯里化简而言之，就是把一个接受多个参数的函数，变成一系列只接受一个参数的函数。例如，假设有一个函数 add(a, b)，它接受两个参数并返回它们的和。那么柯里化之后的 add 变成了一个函数，接受一个参数 a，再返回一个新的函数，这个新的函数再接受一个参数 b，然后返回 a + b 的结果。

用 JavaScript 写个简单的例子：

function add(a) {
    return function(b) {
        return a + b;
    }
}

const add5 = add(5);
console.log(add5(3)); // 输出 8

柯里化主要的好处是提高了函数的灵活性和可重用性，使得部分应用一个函数变得更加方便。

柯里化（Currying）的名字由来

Haskell Curry
这个概念之所以被称为“柯里化”，是因为它以逻辑学家 Haskell Curry 的名字命名。Haskell Curry 在数学和逻辑学领域做出了许多重要贡献，特别是在函数应用和组合子的研究上。
Haskell Curry

然而，尽管是 Curry 的名字被用于这个概念，但柯里化这个技术实际上是由另一个人提出的——Moses Schönfinkel。他在 1924 年提出了这个概念，不过后来是 Curry 把这个技术推广开来并使之广为人知。因此，为了纪念 Curry 的贡献，人们把这种技术命名为“Currying”。

有趣的是，Haskell Curry 这个名字在编程界还有另一个重要的关联——函数式编程语言 Haskell 也是以他的名字命名的。Haskell 语言本身就大量使用了柯里化等函数式编程的概念。

在 Haskell 这样纯函数式小众编程语言中，所有函数实际上都是柯里化的。这意味着一个多参数函数实际上是多个一元函数的嵌套。

add :: Int -> Int -> Int
add a b = a + b

add5 :: Int -> Int
add5 = add 5

main = print (add5 3) -- 输出 8

以上就是纯正的函数式编程，我断定会使用Haskell语言的小伙伴们应该寥寥无几，本人曾经为了准备一场笔试，曾在一个周末馒头苦学Haskell，强行消化各种晦涩的函数理念，以及递归编程范式，克服种种函数编程对传统的、面向对象的编程思想带来的冲击，才得以侥幸顺利通过。

什么是 std::bind

在 C++ 中，std::bind 是一个强大的工具，能够将函数与其部分参数绑定生成新的函数对象，这在需要部分应用函数、延迟调用以及函数式编程中非常有用。std::bind 可以与普通函数、成员函数、函数对象、以及 lambda 表达式一起使用，极大地提高了代码的灵活性和可重用性。

std::bind 位于 <functional> 头文件中，通过将函数或函数对象与参数进行绑定，生成一个新的可调用对象。其基本用法如下：

#include <functional>
auto bound_func = std::bind(函数或函数对象, 参数...);

使用 std::bind 时，std::placeholders 提供了一组占位符，用于指示参数的位置：

  • std::placeholders::_1 表示第一个位置的参数
  • std::placeholders::_2 表示第二个位置的参数
  • std::placeholders::_3 表示第三个位置的参数
  • 以此类推…

通过使用占位符，开发者可以灵活地定义函数参数的位置和绑定方式。

用 std::bind 实现柯里化

C++ 中的 std::bind 是一个强大的工具，它让我们能够绑定函数的一部分参数，生成新的函数对象。这对于实现柯里化非常有帮助。

一个基本的绑定例子

#include <iostream>
#include <functional>

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add_with_5 = std::bind(add, 5, std::placeholders::_1); // 绑定函数的第一个参数
    std::cout << add_with_5(3) << std::endl; // 输出 8
    return 0;
}

在这个例子中，我们用 std::bind 绑定了 add 函数的第一个参数为 5，生成了一个新的函数对象。这个新函数对象接受一个参数，然后返回 5 加上这个参数的结果。

简单的柯里化

我们可以扩展这个例子，看看如何用 std::bind 实现柯里化。

#include <iostream>
#include <functional>

// 定义一个普通的三参数函数
int add(int a, int b, int c) {
    return a + b + c;
}

// 定义一个柯里化函数
auto curry_add = [](int a) {
    return std::bind(add, a, std::placeholders::_1, std::placeholders::_2);
};

int main() {
    // 使用柯里化函数
    auto add_with_5 = curry_add(5);
    std::cout << add_with_5(3, 2) << std::endl; // 输出 10 (5+3+2)
    
    // 再进一步绑定第二个参数
    auto add_with_5_and_3 = std::bind(add_with_5, 3, std::placeholders::_1);
    std::cout << add_with_5_and_3(2) << std::endl; // 输出 10 (5+3+2)

    return 0;
}

在这个例子中，我们首先定义了一个 add 函数，然后用 lambda 表达式 curry_add 实现了对 add 的柯里化。curry_add 生成一个新的函数，这个新函数部分绑定了 add 的第一个参数。接着，我们可以进一步绑定第二个参数，直到达到我们想要的结果。

柯里化（Currying）的实际应用

柯里化在实际编程中的应用场景非常广泛。例如，在处理事件、组合函数、配置函数参数等等场景。它能让我们的代码更加灵活和可复用。

举个例子

假设我们有一个日志记录函数 log，它包含三个参数：日志级别、日志模块和日志信息。如果我们经常需要记录某个固定模块的日志，可以把它部分应用成一个新的函数。

#include <iostream>
#include <functional>
#include <string>

void log(const std::string& level, const std::string& module, const std::string& message) {
    std::cout << "[" << level << "] " << module << ": " << message << std::endl;
}

int main() {
    // 将模块名固定为 "Network"
    auto network_log = std::bind(log, std::placeholders::_1, "Network", std::placeholders::_2);

    // 使用新的日志函数记录不同级别的日志
    network_log("INFO", "Connected to server");
    network_log("ERROR", "Failed to connect to server");

    return 0;
}

在这个例子中，我们用 std::bind 把 log 函数的模块参数部分应用成 “Network”，生成了一个新的日志记录函数 network_log。这样我们就不用每次记录日志时都传递模块名了。

其他案例

std::bind的功能绝非单一，下面让我们来展示一下它多才多艺的其他方面。

示例 1：绑定成员函数

使用 std::bind 绑定成员函数时，我们需要指定调用对象。

#include <iostream>
#include <functional>

class MyClass {
public:
    void sayHello(const std::string& name) const {
        std::cout << "Hello, " << name << "!" << std::endl;
    }
};

int main() {
    MyClass obj;
    // 绑定成员函数，需要指定对象
    auto bound_func = std::bind(&MyClass::sayHello, &obj, std::placeholders::_1);

    // 使用新的函数对象
    bound_func("Alice"); // 输出：Hello, Alice!

    return 0;
}

在这个例子中，我们将 MyClass 的成员函数 sayHello 绑定到对象 obj 上，并且将单参数 name 作为占位符。

示例 2：绑定函数对象

函数对象（functor）也可以与 std::bind 一起使用。

#include <iostream>
#include <functional>

class Multiply {
public:
    int operator()(int a, int b) const {
        return a * b;
    }
};

int main() {
    Multiply multiply;
    // 绑定函数对象，将第一个参数固定为2
    auto times_two = std::bind(multiply, 2, std::placeholders::_1);

    // 使用新的函数对象
    std::cout << times_two(5) << std::endl; // 输出 10 (2*5)

    return 0;
}

在这个例子中，我们通过 std::bind 将函数对象 Multiply 的第一个参数绑定为 2，生成一个新的函数对象 times_two，它只接受一个参数，并将其与 2 相乘。

示例 3：绑定 Lambda 表达式

我们甚至可以将 lambda 表达式与 std::bind 一起使用，进一步提高代码的灵活性。

#include <iostream>
#include <functional>

int main() {
    auto lambda = [](int a, int b, int c) {
        return a * b + c;
    };

    // 绑定lambda，将前两个参数固定为2和3
    auto bound_lambda = std::bind(lambda, 2, 3, std::placeholders::_1);

    // 使用新的函数对象
    std::cout << bound_lambda(4) << std::endl; // 输出 10 (2*3+4)

    return 0;
}

在这个例子中，我们将 lambda 表达式的前两个参数固定为 2 和 3，生成一个新的函数对象，它接收一个参数作为 lambda 表达式的第三个参数。

quote-the-most-fundamental-problem-in-software-development-is-complexity

结语

std::bind 是 C++ 标准库中非常重要的工具，能够将函数与其部分参数绑定生成新的函数对象。它能够与普通函数、成员函数、函数对象以及 lambda 表达式一起使用，极大地提高了代码的灵活性和可重用性。通过掌握 std::bind，开发者可以在 C++ 中更好地实现函数式编程中的柯里化理念，写出更清晰、更简洁的代码。希望这篇文章能帮助你更好地理解和应用 std::bind，提升你的 C++ 编程技巧。如果你有任何问题或心得，欢迎在评论区讨论！

相关文章