第四节 · 小别致 · 枚举与联合类

Lambda 是 C++11 引入的匿名函数，随着标准的演进变得越来越强大。

---

Lambda 基础回顾

int main()
{
    // 基本语法
    auto add = [](int a, int b) { return a + b; };
    cout << add(1, 2) << endl;  // 3
    
    // 捕获列表
    int x = 10;
    auto addX = [x](int a) { return a + x; };  // 值捕获
    auto addXRef = [&x](int a) { return a + x; };  // 引用捕获
    
    // 捕获全部
    auto f1 = [=]() { return x; };   // 值捕获所有
    auto f2 = [&]() { return x; };   // 引用捕获所有
    
    return 0;
}

---

mutable Lambda

int main()
{
    int x = 10;
    
    // 值捕获的变量默认是 const
    auto f = [x]() mutable {
        x++;  // 需要 mutable 才能修改
        return x;
    };
    
    cout << f() << endl;  // 11
    cout << f() << endl;  // 12
    cout << x << endl;    // 10（原变量不变）
    
    return 0;
}

---

初始化捕获（C++14）

int main()
{
    // 移动捕获
    unique_ptr<int> p = make_unique<int>(42);
    auto f = [p = move(p)]() {
        return *p;
    };
    // p 现在是空的
    
    // 创建新变量
    auto g = [x = 10, y = 20]() {
        return x + y;
    };
    
    // 重命名
    int value = 100;
    auto h = [v = value]() {
        return v * 2;
    };
    
    return 0;
}

---

泛型 Lambda（C++14）

int main()
{
    // auto 参数
    auto add = [](auto a, auto b) {
        return a + b;
    };
    
    cout << add(1, 2) << endl;        // 3
    cout << add(1.5, 2.5) << endl;    // 4.0
    cout << add("Hello"s, "World"s) << endl;  // HelloWorld
    
    // 完美转发
    auto wrapper = [](auto&& arg) {
        return forward<decltype(arg)>(arg);
    };
    
    return 0;
}

---

模板 Lambda（C++20）

int main()
{
    // 显式模板参数
    auto add = []<typename T>(T a, T b) {
        return a + b;
    };
    
    // 带约束
    auto print = []<typename T>
        requires requires(T t) { cout << t; }
    (const T& value) {
        cout << value << endl;
    };
    
    // 可变参数模板 Lambda
    auto printAll = []<typename... Args>(Args&&... args) {
        ((cout << args << " "), ...);
        cout << endl;
    };
    
    printAll(1, 2.0, "three");
    
    return 0;
}

---

立即调用的 Lambda（IIFE）

int main()
{
    // 立即调用
    int result = []() {
        int sum = 0;
        for (int i = 1; i <= 10; ++i)
            sum += i;
        return sum;
    }();  // 注意这里的 ()
    
    cout << result << endl;  // 55
    
    // 用于复杂初始化
    const auto config = []() {
        Config c;
        c.load("config.txt");
        c.validate();
        return c;
    }();
    
    return 0;
}

---

递归 Lambda

int main()
{
    // 方法 1：用 function（有开销）
    function<int(int)> factorial = [&factorial](int n) {
        return n <= 1 ? 1 : n * factorial(n - 1);
    };
    
    // 方法 2：使用 Y 组合子技巧
    auto factorial2 = [](auto&& self, int n) -> int {
        return n <= 1 ? 1 : n * self(self, n - 1);
    };
    cout << factorial2(factorial2, 5) << endl;  // 120
    
    // C++23: deducing this
    // auto factorial3 = [](this auto&& self, int n) {
    //     return n <= 1 ? 1 : n * self(n - 1);
    // };
    
    return 0;
}

---

Lambda 与 STL

int main()
{
    vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    
    // 排序
    sort(v.begin(), v.end(), [](int a, int b) {
        return a > b;  // 降序
    });
    
    // 过滤
    v.erase(
        remove_if(v.begin(), v.end(), [](int x) {
            return x < 3;
        }),
        v.end()
    );
    
    // 转换
    transform(v.begin(), v.end(), v.begin(), [](int x) {
        return x * 2;
    });
    
    // 累加
    int sum = accumulate(v.begin(), v.end(), 0, [](int a, int b) {
        return a + b;
    });
    
    return 0;
}

---

捕获 this

class Counter
{
    int value = 0;
    
public:
    auto getIncrementer()
    {
        // 捕获 this 指针
        return [this]() {
            return ++value;
        };
    }
    
    auto getSafeIncrementer()
    {
        // C++17: 复制 *this
        return [*this]() mutable {
            return ++value;  // 修改的是副本
        };
    }
    
    int getValue() const { return value; }
};

int main()
{
    Counter c;
    auto inc = c.getIncrementer();
    
    cout << inc() << endl;  // 1
    cout << inc() << endl;  // 2
    cout << c.getValue() << endl;  // 2
    
    return 0;
}

---

Lambda 的类型

int main()
{
    // 每个 Lambda 都有独特的类型
    auto f1 = []() {};
    auto f2 = []() {};
    
    // decltype(f1) != decltype(f2)
    // 即使代码完全相同
    
    // 转换为 function
    function<int(int)> func = [](int x) { return x * 2; };
    
    // 无捕获的 Lambda 可以转换为函数指针
    int (*ptr)(int) = [](int x) { return x * 2; };
    cout << ptr(21) << endl;  // 42
    
    return 0;
}

---

实用模式

// 作用域守卫
template<typename F>
class ScopeGuard
{
    F func;
    bool active = true;
    
public:
    ScopeGuard(F f) : func(move(f)) {}
    ~ScopeGuard() { if (active) func(); }
    void dismiss() { active = false; }
};

int main()
{
    FILE* fp = fopen("test.txt", "w");
    auto guard = ScopeGuard([fp]() {
        if (fp) fclose(fp);
    });
    
    // 无论如何退出，文件都会被关闭
    
    return 0;
}

---

习题

• 实现一个接受任意数量 Lambda 的 compose 函数。

• 使用 Lambda 实现一个简单的延迟计算（lazy evaluation）。

• 比较 Lambda 和函数对象的性能差异。