Cpp lambda and bind
基本表达式
[capture](parameters) -> return-type {body}当没有返回类型时, 可以省略 -> return-type
变量捕获与lambda闭包实现
[]不截取任何变量[&]截取外部作用域中所有变量，并作为引用在函数体中使用[=]截取外部作用域中所有变量，并拷贝一份在函数体中使用[=, &foo]截取外部作用域中所有变量，并拷贝一份在函数体中使用，但是对foo变量使用引用[bar]截取bar变量并且拷贝一份在函数体中使用，同时不截取其他变量[x, &y]x按值传递，y按引用传递[this]截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。
lambda 的底层实现
lambda 其实是c++的语法糖，是通过c++编译器生成class来实现的，看一个简单的例子。
#include <functional>
using namespace std;
int main(int argc, char* argv[]) {
int x = 0;
int y = 0;
int z = 0;
auto func = [&](int a)->int{x+=a; y++; return x;};
func(1);
return 0;
}通过cppinsights 站点来查看编译器的实现方法
#include <functional>
using namespace std;
int main(int argc, char** argv) {
int x = 0;
int y = 0;
int z = 0;
class __lambda_8_16 {
public:
inline /*constexpr */ int operator()(int a) const {
x = x + a;
y++;
return x;
}
private:
int& x;
int& y;
public:
__lambda_8_16(int& _x, int& _y) : x{_x}, y{_y} {}
};
__lambda_8_16 func = __lambda_8_16{x, y};
static_cast<const __lambda_8_16>(func).operator()(1);
return 0;
}匿名函数在编译器中生成了类 class __lambda_6_16，其中operator()中使用了x和y，参数是引用传参。
lambda 表达式中需要注意的事项
1. mutable 关键字
默认情况下，按值捕获的变量在lambda函数体内是const的，不能修改。使用mutable关键字可以移除这个const限制：
int x = 0;
auto func = [x]() mutable {
x++; // 可以修改，但修改的是副本
return x;
};2. 泛型lambda (C++14)
C++14引入了泛型lambda，可以使用auto作为参数类型：
auto add = [](auto a, auto b) { return a + b; };
std::cout << add(1, 2) << std::endl; // 3
std::cout << add(1.5, 2.5) << std::endl; // 4.03. 捕获时初始化 (C++14)
可以在捕获列表中初始化变量，这对于捕获只能移动的类型特别有用：
std::unique_ptr<int> ptr = std::make_unique<int>(42);
auto func = [value = std::move(ptr)]() {
return *value;
};4. 模板lambda (C++20)
C++20引入了模板lambda，可以使用模板语法：
auto func = []<typename T>(T a, T b) { return a + b; };
std::cout << func(1, 2) << std::endl;5. constexpr lambda (C++17)
C++17允许lambda在编译时求值：
constexpr auto square = [](int n) { return n * n; };
static_assert(square(5) == 25);6. this捕获的变化 (C++20)
C++20中，[=]不再隐式捕获this，需要显式捕获：
class MyClass {
int value = 42;
public:
auto getFunc() {
// C++20: 需要显式捕获this
return [=, this]() { return value; };
// 或者使用 [*this] 按值捕获整个对象
}
};7. 生命周期问题
捕获引用时需要特别注意生命周期，避免悬空引用：
std::function<int()> createFunc() {
int x = 42;
// 危险：x在函数返回后被销毁
return [&x]() { return x; };
}
// 正确做法：按值捕获
std::function<int()> createFuncSafe() {
int x = 42;
return [x]() { return x; };
}8. 性能考虑
- lambda通常会被编译器内联，性能接近普通函数
- 避免在性能关键路径中使用复杂的捕获
- 小lambda适合作为算法参数，如
std::sort的比较函数
9. 与std::bind的比较
优先使用lambda而不是std::bind，因为：
- lambda语法更清晰
- 编译器优化更好
- 类型安全更强
- C++14后lambda功能更强大
10. 转换为函数指针
无捕获的lambda可以隐式转换为函数指针：
void callFunc(int (*func)(int)) {
std::cout << func(5) << std::endl;
}
int main() {
auto lambda = [](int x) { return x * 2; };
callFunc(lambda); // 可以转换
}11. lambda参数特性
lambda的参数语法与普通函数类似，但有一些特殊之处：
默认参数
lambda支持默认参数，但需要注意使用场景：
auto greet = [](const std::string& name = "World") {
std::cout << "Hello, " << name << "!" << std::endl;
};
greet(); // Hello, World!
greet("Alice"); // Hello, Alice!引用参数和const引用
可以像普通函数一样使用引用参数：
auto swapValues = [](int& a, int& b) {
int temp = a;
a = b;
b = temp;
};
int x = 5, y = 10;
swapValues(x, y); // x=10, y=5可变参数模板 (C++14)
lambda支持可变参数模板：
auto printAll = [](auto&&... args) {
(std::cout << ... << args) << std::endl;
};
printAll(1, " + ", 2, " = ", 3); // 输出: 1 + 2 = 3参数类型推导
C++14引入的泛型lambda可以自动推导参数类型：
// 自动推导参数类型
auto maxValue = [](auto a, auto b) {
return a > b ? a : b;
};
std::cout << maxValue(3.14, 2.71) << std::endl; // 3.14
std::cout << maxValue(5, 10) << std::endl; // 10参数包展开
可以在lambda体内展开参数包：
auto sumAll = [](auto... args) {
return (args + ...); // 折叠表达式
};
std::cout << sumAll(1, 2, 3, 4, 5) << std::endl; // 15noexcept规范
可以为lambda指定noexcept：
auto safeDivide = [](int a, int b) noexcept -> int {
if (b == 0) return 0; // 注意：noexcept函数中抛出异常会终止程序
return a / b;
};属性说明符 (C++11/14/17)
可以为lambda添加属性说明符：
// [[nodiscard]] 属性 (C++17)
auto createResource = []() [[nodiscard]] {
return std::make_unique<int>(42);
};
// [[deprecated]] 属性
auto oldFunc = []() [[deprecated("Use newFunc instead")]] {
return 42;
};12. 递归lambda
lambda不能直接递归调用自己，需要使用std::function或Y组合子：
// 使用std::function
std::function<int(int)> factorial;
factorial = [&factorial](int n) -> int {
return n <= 1 ? 1 : n * factorial(n - 1);
};
// 使用Y组合子（高级技巧）
auto y = [](auto f) {
return [=](auto... args) {
return f(f, args...);
};
};
auto factorial2 = y([](auto self, int n) -> int {
return n <= 1 ? 1 : n * self(self, n - 1);
});Related Articles
2025-08-08
Cpp Concept
C++20引入的concept是C++模板编程的一项重大特性，用于定义对模板参数的约束，提高模板代码的可读性、错误诊断和维护性。以下是对C++20 concept的详细讲解，包括其背景、语法、用途、设计理念以及实际应用。 1. 背景和动机 在C++20之前，模板编程虽然强大，但存在以下问题： 缺乏明确的约束：模板参数的类型要求通常通过文档或代码中的隐式假设来表达。如果模板的使用不符合要求，编译器会在实例化时产生难以理解的错误信息。 错误信息复杂：模板实例化失败时，编译器通常会输出冗长且晦涩的错误信息，难以快速定位问题。 代码可读性差：开发者需要通过模板元编程或SFINAE（Substitution Failure Is Not An Error）等技术间接约束模板参数，这增加了代码复杂度和学习成本。 concept的引入解决了这些问题，它允许开发者显式地定义模板参数的语义要求，使代码更清晰、错误信息更友好，同时提高编译器的诊断能力。 2. 什么是Concept？ concept是一个命名的约束集合，用于描述模板参数必须满足的条件。它可以看作是对类型或值的语义要求的一种形式化表...
2023-06-27
Boost 中好用的算法
基于 boost 1.82… timer 计时器 过去老的 boost/timer.hpp 已经废弃了，目前推荐使用的是 boost/timer/timer.hpp, 主要包括下面了2个类 class detail boost::timer::cpu_timer 计时器 boost::timer::auto_cpu_timer 计时器，基于cpu_timer实现，在析构的时候输出耗时 struct cpu_times { nanosecond_type wall; // 挂钟时间 nanosecond_type user; // 用户时间 nanosecond_type system; // 系统时间 void clear() {wall = user = system = 0LL; } }; 默认的输出格式为下： “%w s wall, %u s user + %s s system = %t s CPU (%p%)\n” format meaning ...
2025-08-13
C++ Tips
收集一下奇奇怪怪的玩意(包括冷门用法)。。。。 虚函数的默认参数 #include <iostream> using namespace std; class Base { public: virtual void show(int x = 10) = 0; virtual ~Base() { cout << "~Base\n"; } }; class Derive : public Base { public: void show(int x = 20) override { cout << "x = " << x << endl; } ~Derive() override { cout << "~Derive\n"; } }; int main(int argc, char* argv[]) { Base* bb = new D...
2025-01-25
C++ Alignment
内存对齐不是什么花里胡哨的理论玩意儿，它是硬件决定的铁律。忽略它，你的代码要么崩溃，要么性能烂到家。现代C++给了你工具，让你精确控制对齐，而不是祈祷编译器聪明。 为什么对齐重要？ 硬件要求：CPU从内存读取数据必须按特定边界（如4字节、8字节、16字节）。不对齐，访问非法，段错误伺候。 性能杀手：不对齐导致多次内存访问、缓存失效。SIMD指令（SSE/AVX）强制16/32字节对齐，否则零矢量惩罚。 缓存线：现代CPU缓存64字节。不对齐跨缓存线，延迟翻倍。 记住：对齐是优化，不是可选。过度对齐浪费空间，但不足齐更糟。 alignof：查询对齐需求 alignof(T) 返回类型T的最小对齐字节数。简单、直观。 #include <print> int main() { std::print("alignof(char): {}\n", alignof(char)); std::print("alignof(int): {}\n", alignof(int)); std::print("ali...
2025-08-13
C++ CRTP
CRTP CRTP = Curiously Recurring Template Pattern。核心形式是：让派生类把自己作为模板参数传给基类 template<typename Derived> struct Base { /* 使用 static_cast<Derived*>(this) 调用派生接口 */ }; struct Derived : Base<Derived> { /* ... */ }; 这是 静态多态（compile-time polymorphism） 的一种实现：基类在编译期就能调用派生类的方法，达成“没有虚函数表、零运行时开销”的多态。 工作原理（Why / How） 基类通过 static_cast<Derived*>(this) 或 static_cast<const Derived*>(this) 把自己转回派生类型，然后直接调用派生实现。因为在最终对象内确实包含派生子对象，所以在合法用法下这是安全的（前提：对象确实是 Derived 的实例）。 典型例子（代码...
2023-06-21
Cpp Concurrency
cpp11之后，cpp本身对并发的支持大大增强，这里记录一下 1 std::thread class cpp的thread类型，创建即运行，不像java那样需要start，thread表示一个系统资源，一个系统线程 构造函数 function construct constructor 1 thread() noexcept; constructor 2 thread(thread&& other) noexcept; constructor 3 template<class F, class... Args>explicit thread(F&& f, Args&&... args); copy constructor thread(const thread&) = delete; assign copy operator thread& operator=(const thread&) = delete; assign move operator thread...
