C++学习：六个月从基础到就业——C++11/14：lambda表达式-CSDN博客

本文链接：https://blog.csdn.net/qq_53773901/article/details/147704924

C++学习：六个月从基础到就业——C++11/14：lambda表达式

本文是我C++学习之旅系列的第四十篇技术文章，也是第三阶段"现代C++特性"的第二篇，主要介绍C++11/14中引入的lambda表达式。查看完整系列目录了解更多内容。

引言

Lambda表达式是C++11引入的一项重要特性，它允许我们在需要函数对象的地方直接定义内联匿名函数，无需显式定义一个函数或函数对象类。这大大简化了代码，特别是在使用STL算法和回调函数的场景中。C++14进一步扩展了lambda的功能，使其更加灵活和强大。本文将深入探讨lambda表达式的语法、使用方法及实际应用，帮助你充分利用这一强大特性。

Lambda表达式基础

基本语法

Lambda表达式的基本语法如下：

[capture_list](parameters) mutable noexcept -> return_type { body }

其中：

[capture_list]：捕获外部变量的列表（可为空[]）
(parameters)：参数列表（可为空()，与普通函数一样）
mutable：可选，允许修改按值捕获的变量
noexcept：可选，指明函数不抛出异常
-> return_type：可选，指定返回类型（C++11中有时需要，C++14中往往可以省略）
{ body }：函数体

最简单的lambda表达式例子：

#include <iostream>

int main() {
    // 没有参数的lambda
    auto sayHello = []() { std::cout << "Hello, Lambda!" << std::endl; };
    sayHello();  // 输出：Hello, Lambda!
    
    // 带参数的lambda
    auto add = [](int a, int b) { return a + b; };
    std::cout << "5 + 3 = " << add(5, 3) << std::endl;  // 输出：5 + 3 = 8
    
    // 使用auto参数（C++14）
    auto multiply = [](auto a, auto b) { return a * b; };
    std::cout << "5 * 3 = " << multiply(5, 3) << std::endl;       // 整数相乘
    std::cout << "5.5 * 3.5 = " << multiply(5.5, 3.5) << std::endl;  // 浮点数相乘
    
    return 0;
}

捕获列表详解

捕获列表指定了lambda可以访问的外部作用域中的变量：

1. 值捕获

使用值捕获时，lambda在创建时获取变量的副本：

#include <iostream>

int main() {
    int x = 10;
    
    // 按值捕获x
    auto lambda = [x]() { 
        std::cout << "Captured x: " << x << std::endl; 
    };
    
    x = 20;  // 修改原始变量
    lambda();  // 输出：Captured x: 10，因为lambda捕获的是创建时的副本
    
    return 0;
}

2. 引用捕获

使用引用捕获时，lambda可以访问并修改原始变量：

#include <iostream>

int main() {
    int x = 10;
    
    // 按引用捕获x
    auto lambda = [&x]() {
        std::cout << "Before modification x: " << x << std::endl;
        x = 30;  // 修改原始变量
        std::cout << "After modification x: " << x << std::endl;
    };
    
    lambda();  // 修改x
    std::cout << "x in main(): " << x << std::endl;  // 显示修改后的值：30
    
    return 0;
}

3. 隐式捕获

使用[=]或[&]可以隐式捕获所有使用的变量：

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    
    // 隐式按值捕获所有变量
    auto lambda1 = [=]() { 
        std::cout << "Captured x: " << x << ", y: " << y << std::endl; 
    };
    
    // 隐式按引用捕获所有变量
    auto lambda2 = [&]() {
        x = 30;
        y = 40;
        std::cout << "Modified x: " << x << ", y: " << y << std::endl;
    };
    
    lambda1();  // 输出：Captured x: 10, y: 20
    lambda2();  // 修改原始变量并输出：Modified x: 30, y: 40
    std::cout << "After lambda2: x = " << x << ", y = " << y << std::endl;  // 显示修改后的值
    
    return 0;
}

4. 混合捕获

可以混合使用显式和隐式捕获：

// 隐式按值捕获所有变量，但x按引用捕获
auto lambda = [=, &x]() { 
    x = y + z;  // 可以修改x，但不能修改y和z
};

// 隐式按引用捕获所有变量，但x按值捕获
auto lambda = [&, x]() { 
    y = x + z;  // 可以修改y和z，但不能修改x
};

5. 初始化捕获（C++14）

C++14允许在捕获列表中初始化变量：

#include <iostream>
#include <memory>

int main() {
    // 初始化捕获
    auto ptr = std::make_unique<int>(10);
    
    // 在捕获列表中移动unique_ptr的所有权
    auto lambda = [value = std::move(ptr)]() {
        if (value) {
            std::cout << "Captured value: " << *value << std::endl;
        }
    };
    
    // ptr现在为nullptr
    std::cout << "ptr is " << (ptr ? "not null" : "null") << std::endl;
    
    lambda();  // 输出：Captured value: 10
    
    return 0;
}

mutable关键字

默认情况下，lambda表达式无法修改按值捕获的变量。使用mutable关键字可以解除这个限制：

#include <iostream>

int main() {
    int x = 10;
    
    // 没有mutable，尝试修改x会导致编译错误
    // auto lambda1 = [x]() { x = 20; };  // 编译错误
    
    // 使用mutable允许修改值捕获的变量
    auto lambda2 = [x]() mutable {
        x = 20;  // 可以修改捕获的副本，但不影响外部原始变量
        std::cout << "Inside lambda: x = " << x << std::endl;
    };
    
    lambda2();  // 输出：Inside lambda: x = 20
    std::cout << "Outside lambda: x = " << x << std::endl;  // 输出：Outside lambda: x = 10
    
    return 0;
}

返回类型推导

在C++11中，当lambda的函数体包含单一return语句时，返回类型可以自动推导。在其他情况下，需要显式指定返回类型：

#include <iostream>

int main() {
    // 返回类型自动推导为int
    auto add = [](int a, int b) { return a + b; };
    
    // 复杂情况需要显式指定返回类型（C++11）
    auto getValueC11 = [](bool condition) -> int {
        if (condition) {
            return 42;
        } else {
            return 0;
        }
    };
    
    std::cout << "Add result: " << add(5, 3) << std::endl;
    std::cout << "True condition: " << getValueC11(true) << std::endl;
    std::cout << "False condition: " << getValueC11(false) << std::endl;
    
    return 0;
}

C++14增强了返回类型推导，即使在复杂情况下也能自动推导返回类型：

#include <iostream>
#include <string>

int main() {
    // C++14中返回类型自动推导，即使有多个return语句
    auto getValueC14 = [](bool condition) {
        if (condition) {
            return 42;
        } else {
            return 0;
        }
    };
    
    // 不同类型的返回值也可以推导（根据上下文转换）
    auto convertC14 = [](bool condition) {
        if (condition) {
            return 42;      // int
        } else {
            return 42.0;    // double
        }
    };  // 返回类型被推导为double
    
    std::cout << "Type of convertC14 result: " << typeid(convertC14(true)).name() << std::endl;
    
    return 0;
}

Lambda表达式的进阶特性

泛型Lambda（C++14）

C++14引入了泛型lambda，允许在参数中使用auto关键字：

#include <iostream>
#include <vector>
#include <string>

int main() {
    // 泛型lambda，可以接受任何类型的参数
    auto print = [](const auto& value) {
        std::cout << "Value: " << value << std::endl;
    };
    
    print(42);             // 整数
    print(3.14159);        // 浮点数
    print("Hello");        // 字符串字面量
    print(std::string("World"));  // std::string对象
    
    // 处理不同容器
    auto sumElements = [](const auto& container) {
        typename std::decay<decltype(container)>::type::value_type sum{};
        for (const auto& elem : container) {
            sum += elem;
        }
        return sum;
    };
    
    std::vector<int> intVec = {1, 2, 3, 4, 5};
    std::vector<double> doubleVec = {1.1, 2.2, 3.3, 4.4, 5.5};
    
    std::cout << "Sum of integers: " << sumElements(intVec) << std::endl;
    std::cout << "Sum of doubles: " << sumElements(doubleVec) << std::endl;
    
    return 0;
}

Lambda表达式的类型

每个lambda表达式都有唯一的闭包类型，该类型只有编译器知道。我们通常使用auto来存储lambda：

auto lambda = []() { std::cout << "Hello" << std::endl; };

如果需要存储具有相同签名的不同lambda，可以使用std::function：

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

int main() {
    // 使用std::function存储lambda
    std::function<int(int, int)> operation;
    
    bool use_addition = true;
    
    if (use_addition) {
        operation = [](int a, int b) { return a + b; };
    } else {
        operation = [](int a, int b) { return a * b; };
    }
    
    std::cout << "Result: " << operation(5, 3) << std::endl;  // 输出：Result: 8
    
    // 存储多个相同签名的lambda
    std::vector<std::function<int(int)>> transformations;
    
    transformations.push_back([](int x) { return x * x; });         // 平方
    transformations.push_back([](int x) { return x + x; });         // 加倍
    transformations.push_back([](int x) { return x * x * x; });     // 立方
    
    int value = 5;
    for (const auto& transform : transformations) {
        std::cout << "Transformed: " << transform(value) << std::endl;
    }
    
    return 0;
}

递归Lambda

Lambda表达式也可以递归调用自身，但需要一些技巧：

#include <iostream>
#include <functional>

int main() {
    // 使用std::function和引用捕获实现递归
    std::function<int(int)> factorial;
    
    factorial = [&factorial](int n) {
        return (n <= 1) ? 1 : n * factorial(n - 1);
    };
    
    std::cout << "Factorial of 5: " << factorial(5) << std::endl;  // 输出：120
    
    // C++14中的另一种方法：使用Y-combinator技巧
    auto Y = [](auto lambda) {
        return [=](auto... args) {
            return lambda(lambda, args...);
        };
    };
    
    auto factorial_y = Y([](auto self, int n) -> int {
        return (n <= 1) ? 1 : n * self(self, n - 1);
    });
    
    std::cout << "Y-combinator factorial of 5: " << factorial_y(5) << std::endl;  // 输出：120
    
    return 0;
}

实际应用示例

与STL算法结合使用

Lambda表达式与STL算法结合使用是最常见、最有用的场景之一：

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

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // 使用lambda过滤元素
    auto evenCount = std::count_if(numbers.begin(), numbers.end(), 
        [](int n) { return n % 2 == 0; });
    std::cout << "Number of even elements: " << evenCount << std::endl;
    
    // 使用lambda转换元素
    std::transform(numbers.begin(), numbers.end(), numbers.begin(),
        [](int n) { return n * n; });
    
    std::cout << "After squaring: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    // 自定义排序
    std::vector<std::pair<std::string, int>> people = {
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 20},
        {"David", 35}
    };
    
    // 按年龄排序
    std::sort(people.begin(), people.end(), 
        [](const auto& a, const auto& b) { return a.second < b.second; });
    
    std::cout << "People sorted by age:" << std::endl;
    for (const auto& person : people) {
        std::cout << person.first << ": " << person.second << std::endl;
    }
    
    // 使用lambda进行累加
    auto sum = std::accumulate(numbers.begin(), numbers.end(), 0,
        [](int total, int value) { return total + value; });
    std::cout << "Sum of squares: " << sum << std::endl;
    
    return 0;
}

事件处理与回调函数

Lambda表达式非常适合用作回调函数：

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

class Button {
private:
    std::string name;
    std::function<void()> clickHandler;
    
public:
    Button(const std::string& n) : name(n) {}
    
    void setClickHandler(std::function<void()> handler) {
        clickHandler = handler;
    }
    
    void click() {
        std::cout << "Button '" << name << "' clicked" << std::endl;
        if (clickHandler) {
            clickHandler();
        }
    }
};

class EventSystem {
private:
    std::vector<std::function<void(const std::string&)>> eventListeners;
    
public:
    void addEventListener(std::function<void(const std::string&)> listener) {
        eventListeners.push_back(listener);
    }
    
    void triggerEvent(const std::string& eventName) {
        std::cout << "Event '" << eventName << "' triggered" << std::endl;
        for (const auto& listener : eventListeners) {
            listener(eventName);
        }
    }
};

int main() {
    // 按钮回调示例
    Button saveButton("Save");
    Button cancelButton("Cancel");
    
    int saveCount = 0;
    
    saveButton.setClickHandler([&saveCount]() {
        std::cout << "Saving data..." << std::endl;
        ++saveCount;
        std::cout << "Data has been saved " << saveCount << " times" << std::endl;
    });
    
    cancelButton.setClickHandler([]() {
        std::cout << "Operation cancelled" << std::endl;
    });
    
    saveButton.click();
    cancelButton.click();
    saveButton.click();
    
    // 事件系统示例
    EventSystem events;
    
    // 添加监听器
    events.addEventListener([](const std::string& event) {
        std::cout << "Listener 1 received: " << event << std::endl;
    });
    
    events.addEventListener([](const std::string& event) {
        std::cout << "Listener 2 received: " << event << std::endl;
    });
    
    // 触发事件
    events.triggerEvent("application_start");
    events.triggerEvent("user_login");
    
    return 0;
}

自定义迭代器和生成器

Lambda表达式可以用于创建自定义迭代器和生成器：

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

// 简单的整数序列生成器
std::function<int()> makeIntGenerator(int start, int step) {
    return [start, step]() mutable {
        int current = start;
        start += step;
        return current;
    };
}

// 斐波那契序列生成器
std::function<int()> makeFibonacciGenerator() {
    return [a = 0, b = 1]() mutable {
        int current = a;
        int next_val = a + b;
        a = b;
        b = next_val;
        return current;
    };
}

int main() {
    // 使用整数生成器
    auto intGen = makeIntGenerator(1, 2);  // 生成1, 3, 5, 7, ...
    std::cout << "Generated integers: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << intGen() << " ";
    }
    std::cout << std::endl;
    
    // 使用斐波那契生成器
    auto fibGen = makeFibonacciGenerator();  // 生成0, 1, 1, 2, 3, 5, ...
    std::cout << "Fibonacci sequence: ";
    for (int i = 0; i < 10; ++i) {
        std::cout << fibGen() << " ";
    }
    std::cout << std::endl;
    
    // 生成器与STL算法结合
    std::vector<int> numbers(10);
    auto gen = makeIntGenerator(0, 5);  // 生成0, 5, 10, 15, ...
    std::generate(numbers.begin(), numbers.end(), gen);
    
    std::cout << "Generated vector: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

IIFE (立即调用的函数表达式)

Lambda表达式可以实现JavaScript中流行的IIFE模式：

#include <iostream>
#include <vector>

int main() {
    // 普通变量初始化
    int result = 0;
    for (int i = 1; i <= 10; ++i) {
        result += i;
    }
    std::cout << "Sum: " << result << std::endl;
    
    // 使用IIFE初始化
    int sum = [](int n) {
        int total = 0;
        for (int i = 1; i <= n; ++i) {
            total += i;
        }
        return total;
    }(10);
    
    std::cout << "Sum using IIFE: " << sum << std::endl;
    
    // 复杂对象初始化
    std::vector<int> primes = []{
        std::vector<int> p;
        p.push_back(2);
        p.push_back(3);
        p.push_back(5);
        p.push_back(7);
        p.push_back(11);
        return p;
    }();
    
    std::cout << "Prime numbers: ";
    for (int prime : primes) {
        std::cout << prime << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

C++14中的Lambda增强

C++14对lambda表达式进行了几项重要增强：

1. 泛型Lambda

如前所述，C++14引入了泛型lambda，允许在参数中使用auto关键字。

2. 初始化捕获

C++14允许在捕获列表中初始化新变量：

#include <iostream>
#include <memory>
#include <utility>

int main() {
    std::string message = "Hello";
    
    // C++11必须这样写
    auto lambda1 = [message = message + " World!"]() {
        std::cout << message << std::endl;
    };
    
    // 移动构造情况
    auto resource = std::make_unique<int>(42);
    
    // 在C++11中无法捕获unique_ptr
    auto lambda2 = [resource = std::move(resource)]() {
        std::cout << "Resource value: " << *resource << std::endl;
    };
    
    lambda1();  // 输出：Hello World!
    lambda2();  // 输出：Resource value: 42
    
    // 原始resource现在是nullptr
    std::cout << "Original resource is " 
              << (resource ? "valid" : "nullptr") << std::endl;
    
    return 0;
}

3. 返回类型推导改进

C++14中，编译器可以从lambda体中推导出返回类型，即使函数体包含多个返回语句。

Lambda表达式的性能考量

Lambda表达式通常被编译为内联函数对象，性能与手写函数对象相当。一些注意事项：

捕获的开销：
- 值捕获会创建变量的副本，可能有额外开销
- 引用捕获几乎没有额外开销
内联优化：
- 简单的lambda通常会被内联，没有函数调用开销
- 但过大的lambda可能不会被内联
std::function的开销：
- std::function比直接使用lambda有更多开销
- 当需要多态行为时才使用std::function

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

// 时间测量辅助函数
template<typename Func>
long long measureTime(Func func, int iterations) {
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < iterations; ++i) {
        func(i);
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    return std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
}

int main() {
    const int iterations = 10000000;
    
    // 测试直接使用lambda
    auto directLambda = [](int x) { return x * x; };
    
    // 测试通过std::function存储的lambda
    std::function<int(int)> funcLambda = [](int x) { return x * x; };
    
    // 测试值捕获
    int multiplier = 2;
    auto valueLambda = [multiplier](int x) { return x * multiplier; };
    
    // 测试引用捕获
    auto refLambda = [&multiplier](int x) { return x * multiplier; };
    
    // 测试性能
    auto directTime = measureTime([&](int i) { directLambda(i); }, iterations);
    auto funcTime = measureTime([&](int i) { funcLambda(i); }, iterations);
    auto valueTime = measureTime([&](int i) { valueLambda(i); }, iterations);
    auto refTime = measureTime([&](int i) { refLambda(i); }, iterations);
    
    std::cout << "Direct lambda: " << directTime << " ns" << std::endl;
    std::cout << "std::function lambda: " << funcTime << " ns" << std::endl;
    std::cout << "Value capture lambda: " << valueTime << " ns" << std::endl;
    std::cout << "Reference capture lambda: " << refTime << " ns" << std::endl;
    
    return 0;
}

最佳实践与注意事项

何时使用Lambda

简短的一次性函数：特别是作为算法参数
需要捕获局部变量的函数：当需要访问作用域中的变量
回调函数：事件处理或异步操作的回调
在本地定义辅助函数：不需要在全局或类范围内可见的函数

避免常见错误

捕获的生命周期问题：

std::function<int()> createLambda() {
    int local = 42;
    // 危险！返回的lambda捕获了即将销毁的局部变量的引用
    return [&local]() { return local; };  // 引用已销毁的变量
}

// 安全版本：按值捕获
std::function<int()> createSafeLambda() {
    int local = 42;
    return [local]() { return local; };  // 复制了local的值
}

捕获this指针：

class Widget {
private:
    int value = 42;
    
public:
    // 危险，隐式捕获this可能导致悬挂指针
    auto badClosure() {
        return [=]() { return value; };  // 隐式捕获this
    }
    
    // C++14安全版本：显式捕获成员变量
    auto goodClosureC14() {
        return [value = value]() { return value; };
    }
    
    // C++11安全版本：显式复制需要的数据
    auto goodClosureC11() {
        int v = value;
        return [v]() { return v; };
    }
};

按值捕获且修改：

int counter = 0;

// 错误：无法修改按值捕获的变量
// auto increment = [counter]() { ++counter; };  // 编译错误

// 正确：使用mutable关键字
auto increment = [counter]() mutable { ++counter; return counter; };

提高Lambda可读性

保持简短：长函数应提取为命名函数
使用适当的捕获方式：明确指定需要捕获的变量
考虑命名lambda：对于复杂lambda，使用auto给它一个有意义的名字
适当添加注释：特别是对于复杂的逻辑

// 不要这样做：过于复杂的lambda
std::sort(employees.begin(), employees.end(), 
    [](const Employee& a, const Employee& b) {
        if (a.department != b.department)
            return a.department < b.department;
        if (a.salary != b.salary)
            return a.salary > b.salary;  // 注意：薪水是降序排列
        return a.name < b.name;
    });

// 更好的做法：命名lambda提高可读性
auto compareEmployees = [](const Employee& a, const Employee& b) {
    // 首先按部门升序排序
    if (a.department != b.department)
        return a.department < b.department;
    
    // 然后在同一部门内按薪水降序排序
    if (a.salary != b.salary)
        return a.salary > b.salary;
    
    // 最后按姓名字母顺序排序
    return a.name < b.name;
};

std::sort(employees.begin(), employees.end(), compareEmployees);