C++函数式编程风潮

# 1. C++函数式编程概述

在当今软件开发领域，函数式编程（FP）作为一种强调数学函数概念的编程范式，正逐渐受到重视。C++，作为一门支持多种编程范式的语言，也在其最新的标准中增加了对函数式编程的支持。在C++中，函数式编程不仅包括了无副作用的函数调用，还包括了诸如高阶函数、柯里化、模板元编程等特性。本章旨在为读者提供一个关于C++函数式编程的基础性介绍，帮助读者理解函数式编程在C++中的作用，并为后续章节更深入的探讨打下坚实的基础。

# 2. C++中的函数式特性

### 2.1 函数对象和lambda表达式

#### 2.1.1 函数对象的基础和用法

函数对象（Functors），也被称为可调用对象，是C++中一种行为类似于函数的对象。函数对象最显著的特点是它们可以像普通函数一样被调用。它们通常是通过重载`operator()`来实现的。使用函数对象的好处在于它们可以拥有状态，而普通函数在C++中是无状态的。

函数对象可以用普通类实现，也可以使用`std::function`。不过，在C++11之前，没有一个统一的方式来表示可调用对象。C++11引入了`std::function`，这使得我们可以用同一方式存储和调用任何类型的可调用实体，包括函数指针、lambda表达式、bind表达式以及函数对象。

下面是一个简单的函数对象例子：

#include <iostream>

class Adder {
public:
    Adder(int n) : num(n) {}
    int operator()(int n) {
        return num + n;
    }
private:
    int num;
};

int main() {
    Adder add5(5);
    std::cout << add5(10) << '\n';  // 输出 15
}

在上述代码中，`Adder` 类重载了 `operator()`，使其成为了一个函数对象。它被实例化为 `add5`，这个实例可以像函数一样被调用，输出结果为 `15`。

#### 2.1.2 lambda表达式的定义和优势

Lambda表达式是C++11中的一个重大特性，它提供了一种简洁且直接的方式来定义匿名函数对象。Lambda表达式的基本语法结构为：`[ capture clause ] (parameters) -> return_type { function_body }`。

Lambda表达式的优势在于，它们提供了一个语法上的便利，可以使得代码更加清晰，并且在需要函数对象的地方，无需显式定义一个新的类或函数。这对于使用STL中的算法特别有用，因为算法往往需要函数对象作为参数。

下面是一个使用lambda表达式的例子：

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    int sum = 0;
    std::for_each(data.begin(), data.end(), [&sum](int n) { sum += n; });
    std::cout << "Sum is " << sum << '\n';  // 输出 Sum is 15
}

在这个例子中，`std::for_each` 使用了一个lambda表达式来累加`data`向量中的所有元素。通过捕获列表`[&sum]`，lambda表达式可以访问并修改`sum`变量。

### 2.2 标准模板库中的函数式编程

#### 2.2.1 algorithm库中的函数式接口

C++标准模板库（STL）中的`<algorithm>`库提供了一系列算法，其中很多都可以用函数式编程范式来实现。函数式接口的算法通常接受一个函数作为参数，并将其应用于容器中的元素。这种方式允许将算法的行为参数化，从而增加了代码的复用性和灵活性。

举个例子，`std::transform`可以使用一个函数将容器中的每个元素转换到另一个容器中：

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> input = {1, 2, 3, 4, 5};
    std::vector<int> output(input.size());
    std::transform(input.begin(), input.end(), output.begin(), [](int n) { return n * n; });
    for (int n : output) {
        std::cout << n << " ";  // 输出 1 4 9 16 25
    }
}

在这个例子中，`std::transform`将`input`向量中的每个元素都映射到其平方，并将结果存储在`output`向量中。

#### 2.2.2 function、bind和placeholder的使用

C++11标准中引入的`std::function`是一个通用的多态函数封装器，它允许将不同类型的可调用实体（如函数指针、lambda表达式、bind表达式等）存储在同一个类型安全的通用接口中。这意味着，我们可以将一个`std::function`对象作为参数传递给算法，只要这个对象的签名与算法所期望的签名一致。

`std::bind`用于绑定函数调用的参数，创建一个新的可调用对象。`std::placeholders`用于在`bind`表达式中指定占位符，表示需要被后续参数填充的位置。

例如：

#include <functional>
#include <iostream>

void print(int a, int b) {
    std::cout << "A: " << a << ", B: " << b << std::endl;
}

int main() {
    auto binder = std::bind(print, std::placeholders::_1, 10);
    binder(20);  // 输出 A: 20, B: 10
}

在这个例子中，`std::bind`创建了一个新的可调用对象`binder`，它将`print`函数的第二个参数绑定为`10`。调用`binder`时，只需要提供第一个参数即可。

### 2.3 C++11新增的函数式特性

#### 2.3.1 auto和decltype关键字

`auto`和`decltype`关键字是C++11中引入的，用于类型推导的新特性。它们与函数式编程密切相关，因为它们使得处理泛型代码和匿名类型变得更加简单。

`auto`关键字让编译器根据初始化表达式自动推导变量的类型。这在使用lambda表达式和STL算法时特别有用，因为它可以简化代码，使得我们不需要重复写复杂的类型声明。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};
    auto square = [](int n) { return n * n; };
    auto result = std::transform(data.begin(), data.end(), data.begin(), square);
    // result 现在是一个 std::vector<int>::iterator
}

在这个例子中，`auto`被用来推导`square`和`result`的类型。

`decltype`关键字用于推导表达式的类型，而不执行表达式，这使得我们可以查询变量或表达式的类型，即使不能实际声明为该类型。

int x = 0;
decltype(x) y = 4;  // y的类型为int

#### 2.3.2 模板元编程的现代用法

模板元编程（TMP）是C++函数式编程的核心部分之一，它允许在编译时进行计算。TMP的一个重要应用是通过递归模板特化来创建编译时的算法，它允许在编译期间进行复杂的计算。

C++11的`constexpr`关键字进一步简化了模板元编程。`constexpr`函数或变量必须能够在编译时求值。这使得编写更加类型安全和高效的模板元编程代码成为可能。

下面是一个`constexpr`函数的例子：

constexpr int factorial(int n) {
    return n <= 1 ? 1 : (n * factorial(n - 1));
}

int main() {
    constexpr int result = factorial(5);
    // result 在编译时计算为 120
}

在这个例子中，`factorial`函数是递归的，并且被标记为`constexpr`，这意味着它可以用于编译时计算。

通过这些新增的特性，C++11不仅增强了函数式编程的能力，也为开发高性能代码提供了更广泛的工具和方法。

# 3. 函数式编程实践技巧

## 3.1 不可变性与函数式编程

### 3.1.1 理解不可变性的重要性

不可变性（Immutability）是函数式编程中的一个重要概念，它指的是对象一旦创建，其状态就不能被改变。在函数式编程中，不可变性是通过引用透明和没有副作用的方式编程，从而确保了程序的行为可预测性和易于理解。

在并发编程中，不可变对象可以避免多线程访