C++进阶——C++11_{ }初始化_lambda_包装器

1、{ }初始化

1.1 C++98的{ }

1.2 C++11的{ }

1.3 C++11中的std::initializer_list

总结一下：

2、lambda

2.1 lambda的语法

2.2 捕捉列表

2.3 lambda的应用

2.4 lambda的原理

3、包装器

3.1 function

3.2 bind

1、{ }初始化

1.1 C++98的{ }

C++98中一般数组和结构体可以用{ }进行初始化。

struct Point
{int _x;int _y;
};int main()
{int array1[] = {1, 2, 3, 4, 5};int array2[5] = {0};Point p = {1, 2};return 0;
}

1.2 C++11的{ }

C++11 以后想统一初始化方式，试图实现一切对象皆可用 { } 初始化，{ } 初始化也叫做列表初始化。

内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，最后优化
了以后变成直接构造。

{ } 初始化的过程中，可以省略 = 。

#include <iostream>
#include <vector>
using namespace std;struct Point
{int _x;int _y;
};class Date
{
public:Date(int year = 1, int month = 1, int day = 1): _year(year), _month(month), _day(day){cout << "Date(int year, int month, int day)" << endl;}Date(const Date& d): _year(d._year), _month(d._month), _day(d._day){cout << "Date(const Date& d)" << endl;}private:int _year;int _month;int _day;
};int main()
{// C++98 支持的初始化方式int a1[] = {1, 2, 3, 4, 5};int a2[5] = {0};Point p = {1, 2};// C++11 支持的初始化方式// 内置类型支持int x1 = {2};// 自定义类型支持// 这里本质是用 {2025, 1, 1} 构造一个 Date 临时对象// 临时对象再去拷贝构造 d1，编译器优化后合二为一变成 {2025, 1, 1} 直接构造初始化 d1// 运行一下，我们可以验证上面的理论，发现是没调用拷贝构造的Date d1 = {2025, 1, 1};// 这里 d2 引用的是 {2024, 7, 25} 构造的临时对象const Date& d2 = {2024, 7, 25};// 需要注意的是 C++98 支持单参数时类型转换，也可以不用 {}Date d3 = {2025};Date d4 = 2025;// 可以省略掉 =Point p1{1, 2};int x2{2};Date d6{2024, 7, 25};const Date& d7{2024, 7, 25};// 不支持，只有 {} 初始化，才能省略 =// Date d8 2025;vector<Date> v;v.push_back(d1);v.push_back(Date(2025, 1, 1));// 比起有名对象和匿名对象传参，这里 {} 更有性价比v.push_back({2025, 1, 1});return 0;
}

1.3 C++11中的std::initializer_list

但是对象容器初始化还是不太方便，比如一个vector对象，我想用N个值去构造初始化，那么我们得实现很多个构造函数才能支持，

vector<int> v1 = {1, 2, 3};
vector<int> v2 = {1, 2, 3, 4, 5};

C++11 库中提出了一个 std::initializer_list 的类，

auto il = { 10, 20, 30 };  // the type of il is an initializer_list

这个类的本质是底层开一个数组，将数据拷贝过来，std::initializer_list 内部有两个指针分别指向数组的开始和结束，支持迭代器遍历。

这是它的文档：initializer_list - C++ Reference 。

容器支持一个 std::initializer_list 的构造函数，也就支持任意多个值构成的初始化。STL 中的容器支持用 {x1, x2, x3...} 进行初始化，就是通过 std::initializer_list 的构造函数支持的。

// 标准库中的声明示例// vector 的 initializer_list 构造函数
vector(initializer_list<value_type> il, const allocator_type& alloc = allocator_type());// list 的 initializer_list 构造函数
list(initializer_list<value_type> il, const allocator_type& alloc = allocator_type());// map 的 initializer_list 构造函数
map(initializer_list<value_type> il,const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type());// 自定义 vector 的简化实现
template<class T>
class vector {
public:typedef T* iterator;  // 迭代器类型// initializer_list 构造函数vector(initializer_list<T> il) {for (auto& e : il) {  // 遍历列表元素push_back(e);     // 逐个插入容器}}private:iterator _start = nullptr;        // 指向首元素iterator _finish = nullptr;       // 指向最后一个元素的下一个位置iterator _endofstorage = nullptr; // 指向存储空间的末尾
};

#include <iostream>
#include <vector>
#include <string>
#include <map>
using namespace std;int main() {// 1. 测试 initializer_list 的基本特性std::initializer_list<int> mylist;mylist = {10, 20, 30};  // 初始化列表赋值// 输出 initializer_list 的大小（通常是固定大小，包含两个指针）cout << "sizeof(mylist): " << sizeof(mylist) << endl;// 2. 验证 initializer_list 的存储位置int i = 0;cout << "mylist.begin(): " << mylist.begin() << endl;  // 指向第一个元素cout << "mylist.end(): " << mylist.end() << endl;      // 指向末尾后一位cout << "&i: " << &i << endl;                          // 对比栈地址// 3. 容器的两种初始化方式对比vector<int> v1({1, 2, 3, 4, 5});       // 直接构造（显式 initializer_list）vector<int> v2 = {1, 2, 3, 4, 5};      // 隐式转换（可能触发拷贝优化）const vector<int>& v3 = {1, 2, 3, 4, 5}; // 引用临时对象（生命周期延长）// 4. map 的嵌套初始化（pair + initializer_list）map<string, string> dict = {{"sort", "排序"}, {"string", "字符串"}};// 5. initializer_list 赋值操作v1 = {10, 20, 30, 40, 50};  // 调用 operator=(initializer_list)return 0;
}

总结一下：

C++11，基本实现了一切对象皆可初始化。

2、lambda

2.1 lambda的语法

lambda 表达式本质是一个匿名函数对象，跟普通函数不同的是它可以定义在函数内部。
lambda 表达式语法层面而言没有类型，所以我们一般是用auto或者模板参数定义的对象去接收。

lambda 表达式的格式：

[capture-list] (parameters) -> return type { function body }

[capture-list]：捕捉列表，编译器根据 [ ] 来判断是否为 lambda 函数。捕捉列表能够捕捉上下文中的变量供 lambda 函数使用，捕捉列表可以传值和传引用捕捉，具体细节在 2.2 中我们再细讲。捕捉列表为空 [ ] 也不能省略。

(parameters)：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同( )一起省略。

-> return type：返回值类型，用追踪返回类型形式(允许将函数的返回类型放在参数列表之后(用->引导))声明函数的返回值类型，没有返回值时此部分可省略。一般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。

{ function body }：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空{ }也不能省略。

#include <iostream>
using namespace std;int main() {// 1. 一个简单的lambda表达式auto add1 = [](int x, int y)->int { return x + y; };cout << add1(1, 2) << endl;  // 输出: 3/* Lambda表达式特性说明：1. 捕捉列表为空也不能省略（必须写[]）2. 参数列表为空可以省略（如func1示例）3. 返回值可以省略，可以通过返回对象自动推导4. 函数体不能省略*/// 2. 无参数、无显式返回类型的lambdaauto func1 = [] {cout << "hello bit" << endl;return 0;};func1();  // 输出: hello bit// 3. 通过引用修改外部变量int a = 0, b = 1;        auto swap1 = [](int& x, int& y) {int tmp = x;x = y;y = tmp;};swap1(a, b);cout << a << ":" << b << endl;  // 输出: 1:0return 0;
}

2.2 捕捉列表

Lambda 表达式的变量捕捉规则

在 lambda 表达式中，默认只能使用 lambda 函数体和参数中的变量。如果想使用外层作用域中的变量，就需要进行捕捉。

第一种捕捉方式：显式捕捉

在捕捉列表中显式指定 传值捕捉 和 传引用捕捉，多个变量用逗号分隔。

[x, y, &z] 表示 x 和 y 值捕捉，z 引用捕捉。

第二种捕捉方式：隐式捕捉

[=] 表示 隐式值捕捉，[&] 表示 隐式引用捕捉。

lambda 表达式中使用了哪些变量，编译器就会自动捕捉哪些变量。即按需捕捉。

第三种捕捉方式：混合捕捉

在捕捉列表中 混合使用隐式捕捉和显式捕捉：

[=, &x] 表示其他变量 隐式值捕捉，x 引用捕捉。

[&, x, y] 表示其他变量 隐式引用捕捉，x 和 y 值捕捉。

混合捕捉规则：

第一个元素必须是 & 或 =。
& 混合捕捉时，后面的捕捉变量必须是 值捕捉。
= 混合捕捉时，后面的捕捉变量必须是 引用捕捉。

Lambda 表达式的变量作用域规则

如果 lambda 表达式定义在函数局部作用域，它可以捕捉 lambda 位置之前定义的局部变量，但不能捕捉 静态局部变量 和 全局变量（它们可以直接使用，无需捕捉）。
如果 lambda 表达式定义在全局位置，捕捉列表必须为空（不能捕捉任何变量）一般也不会定义在全局。

Lambda 的 const 性和 mutable 修饰

默认情况下，传值捕捉是被 const 修饰的，即 传值捕捉的变量不能修改。引用捕捉没有const修饰。
使用 mutable 修饰符（加在参数列表后面）可以取消 const 限制，使 传值捕捉的变量可以修改（但修改的是形参，不影响实参）。
使用 mutable 后，参数列表（）不可省略（即使参数为空）。

#include <iostream>
using namespace std;int x = 0; // 全局变量// 全局lambda的捕捉列表必须为空（全局变量可直接使用，无需捕捉）
auto func_global = []() {x++; // 直接修改全局变量
};int main() {// 局部变量int a = 0, b = 1, c = 2, d = 3;// 1. 显式捕捉：值捕捉a，引用捕捉bauto func1 = [a, &b] {// a++;  // 错误：值捕捉的变量默认const，不可修改b++;    // 正确：引用捕捉可修改return a + b;};cout << func1() << endl;// 2. 隐式值捕捉（=）：自动捕捉所有使用的局部变量（a,b,c）auto func2 = [=] {return a + b + c; // d未使用，不会被捕捉};cout << func2() << endl;// 3. 隐式引用捕捉（&）：自动引用捕捉所有修改的变量auto func3 = [&] {a++; c++; d++; // 全部通过引用修改};func3();cout << a << " " << b << " " << c << " " << d << endl;// 4. 混合捕捉1：默认引用捕捉，显式值捕捉a,bauto func4 = [&, a, b] {// a++; b++;  // 错误：a,b是值捕捉c++; d++;     // 正确：其他变量隐式引用捕捉return a + b + c + d;};func4();cout << a << " " << b << " " << c << " " << d << endl;// 5. 混合捕捉2：默认值捕捉，显式引用捕捉a,bauto func5 = [=, &a, &b] {a++; b++;     // 正确：a,b是引用捕捉// c++; d++;  // 错误：其他变量隐式值捕捉return a + b + c + d;};func5();cout << a << " " << b << " " << c << " " << d << endl;// 6. 静态/全局变量无需捕捉static int m = 0;auto func6 = [] {return x + m; // 直接使用全局和静态变量};// 7. mutable修饰：允许修改值捕捉的副本（不影响外部变量）auto func7 = [=]() mutable {a++; b++; c++; d++; // 修改的是内部副本return a + b + c + d;};cout << func7() << endl;   // 输出副本修改后的值cout << a << " " << b << " " << c << " " << d << endl; // 原变量不变return 0;
}

2.3 lambda的应用

在学习 lambda 表达式之前，我们使用的可调用对象只有函数指针和仿函数对象，函数指针的
类型定义起来比较麻烦，仿函数要定义一个类，相对会比较麻烦。使用 lambda 去定义可调用对象，既简单方便。

lambda 在很多其他地方用起来也很好用。比如线程中定义线程的执行函数逻辑，智能指针中定
制删除器等，lambda 的应用还是很广泛的，以后我们会不断接触到。

struct Goods
{string _name;  // 名字double _price; // 价格int _evaluate; // 评价// ...Goods(const char* str, double price, int evaluate):_name(str), _price(price), _evaluate(evaluate){}
};struct ComparePriceLess
{bool operator()(const Goods& gl, const Goods& gr){return gl._price < gr._price;}
};struct ComparePriceGreater
{bool operator()(const Goods& gl, const Goods& gr){return gl._price > gr._price;}
};int main()
{vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3 }, { "菠萝", 1.5, 4 } };// 类似这样的场景，我们实现仿函数对象或者函数指针支持商品中// 不同项的⽐较，相对还是⽐较⿇烦的，那么这⾥ lambda 就很好⽤了sort(v.begin(), v.end(), ComparePriceLess());sort(v.begin(), v.end(), ComparePriceGreater());sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; });sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate < g2._evaluate;});sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluate > g2._evaluate;});return 0;
}

2.4 lambda的原理

lambda 的原理和范围 for 相似，编译后从汇编指令层的角度看，压根就没有 Lambda 和范围 for 这样的东西。范围 for 底层是迭代器，而 lambda 底层是仿函数对象，也就是说我们写了一个 lambda 以后，编译器会生成一个对应的仿函数的类。

仿函数的类名是编译器按一定规则生成的，保证不同的 lambda 生成的类名不同。

lambda 参数 / 返回类型 / 函数体就是仿函数 operator () 的参数 / 返回类型 / 函数体。

lambda 的捕捉列表本质是初始化 仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉时，编译器要看使用哪些就传哪些对象。

上面的原理，我们可以透过汇编层了解一下，下面第二段汇编层代码印证了上面的原理。

class Rate
{
public:Rate(double rate) : _rate(rate){}double operator()(double money, int year){return money * _rate * year;}private:double _rate;
};int main()
{double rate = 0.49;// lambda 表达式auto r2 = [rate](double money, int year) {return money * rate * year;};// 函数对象（仿函数）Rate r1(rate);r1(10000, 2);  // 调用仿函数r2(10000, 2);  // 调用 lambda// 无参 lambdaauto func1 = [] {cout << "hello world" << endl;};func1();  // 调用无参 lambdareturn 0;
}

// lambda 表达式
auto r2 = [rate](double money, int year) {return money * rate * year;
};// 捕捉列表的 `rate`，可以看到作为 `lambda_1` 类构造函数的参数传递了，
// 这样在初始化成员变量后，才能在下面的 operator() 中使用
// 
// 汇编代码片段：
// 00D8295C  lea         eax,[rate]  
// 00D8295F  push        eax  
// 00D82960  lea         ecx,[r2]  
// 00D82963  call        `main'::`2'::<lambda_1>::<lambda_1> (0D81F80h)  // 函数对象（仿函数）
Rate r1(rate);
// 汇编代码片段：
// 00D82968  sub         esp,8  
// 00D8296B  movsd       xmm0,mmword ptr [rate]  
// 00D82970  movsd       mmword ptr [esp],xmm0  
// 00D82975  lea         ecx,[r1]  
// 00D82978  call        Rate::Rate (0D81438h)  r1(10000, 2);
// 汇编代码片段：
// 00D8297D  push        2  
// 00D8297F  sub         esp,8  
// 00D82982  movsd       xmm0,mmword ptr [__real@40c3880000000000 (0D89B50h)]  
// 00D8298A  movsd       mmword ptr [esp],xmm0  
// 00D8298F  lea         ecx,[r1]  
// 00D82992  call        Rate::operator() (0D81212h)  // 从汇编层可以看到，r2（lambda 对象）的调用本质还是调用 operator()，
// 其类型是 `lambda_1`，这个类型名的规则由编译器自定义，确保不同的 lambda 不冲突
r2(10000, 2);
// 汇编代码片段：
// 00D82999  push        2  
// 00D8299B  sub         esp,8  
// 00D8299E  movsd       xmm0,mmword ptr [__real@40c3880000000000 (0D89B50h)]  
// 00D829A6  movsd       mmword ptr [esp],xmm0  
// 00D829AB  lea         ecx,[r2]  
// 00D829AE  call        `main'::`2'::<lambda_1>::operator() (0D824C0h)

3、包装器

3.1 function

1. std::function 是一个类模板，也是一个包装器。
2. std::function 的实例对象可以包装存储其他的可调用对象，包括函数指针、仿函数、lambda 等，统一类型，存储的可调用对象被称为 std::function 的目标。若 std::function 不含目标，则称它为空。调用空 std::function 的目标会导致抛出 std::bad_function_call 异常。

// 前置声明（未定义的通用模板）
template <class T>
class function;  // undefined base template// 特化版本：支持函数类型签名（返回类型 + 参数列表）
template <class Ret, class... Args>
class function<Ret(Args...)> {// 实现内容（此处未展开）// 通常包含 operator() 以支持函数调用
};

以上是 std::function 的原型，它被定义在 <functional> 头文件中。

官方文档：std::function - cppreference.com

#include <functional>
#include <iostream>
using namespace std;// 普通函数
int f(int a, int b) {return a + b;
}// 仿函数（函数对象）
struct Functor {int operator()(int a, int b) {return a + b;}
};// 类（包含静态和非静态成员函数）
class Plus {
public:Plus(int n = 10) : _n(n) {}// 静态成员函数static int plusi(int a, int b) {return a + b;}// 非静态成员函数（依赖 this 指针）double plusd(double a, double b) {return (a + b) * _n;}private:int _n;
};int main() {// 1. 包装普通函数function<int(int, int)> f1 = f;cout << f1(1, 1) << endl;  // 输出: 2// 2. 包装仿函数对象function<int(int, int)> f2 = Functor();cout << f2(1, 1) << endl;  // 输出: 2// 3. 包装 lambda 表达式function<int(int, int)> f3 = [](int a, int b) { return a + b; };cout << f3(1, 1) << endl;  // 输出: 2// 4. 包装静态成员函数（无需对象实例）function<int(int, int)> f4 = &Plus::plusi;cout << f4(1, 1) << endl;  // 输出: 2// 5. 包装非静态成员函数（需绑定对象）Plus pd(10);  // _n = 10// 方式1：传递对象指针function<double(Plus*, double, double)> f5 = &Plus::plusd;cout << f5(&pd, 1.1, 1.1) << endl;  // 输出: (1.1 + 1.1) * 10 = 22// 方式2：传递对象值（拷贝）function<double(Plus, double, double)> f6 = &Plus::plusd;cout << f6(pd, 1.1, 1.1) << endl;    // 输出: 22// 方式3：传递右值引用function<double(Plus&&, double, double)> f7 = &Plus::plusd;cout << f7(move(pd), 1.1, 1.1) << endl;  // 输出: 22cout << f7(Plus(10), 1.1, 1.1) << endl;  // 输出: 22（临时对象）return 0;
}

静态成员函数不属于对象，不需要传this指针，非静态成员函数需传递this指针，传递对象(会自行取对象地址)或对象地址。

3.2 bind

1. 基本形式（自动推导返回类型）

template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

2. 指定返回类型（C++14 起支持）

template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

bind 是一个函数模板，它也是一个可调用对象的包装器，可以把它看做一个函数适配器( 封装函数/可调用对象)，对接收的 fn 可调用对象进行处理后返回一个可调用对象。

bind 可以用来调整参数个数和参数顺序。bind 也在<functional>这个头文件中。

调用 bind 的一般形式： auto newCallable = bind(callable,arg_list); 其中 newCallable 本身是一个可调用对象，arg_list 是一个逗号分隔的参数列表，对应给定的 callable 的参数。当我们调用 newCallable 时，newCallable 会调用 callable，并传给它 arg_list 中的参数。

arg_list 中的参数可能包含形如 _n 的名字，其中 n 是一个整数，表示 newCallable 的参数。数值 n 表示生成的可调用对象中参数的位置：_1 为 newCallable 的第一个参数(无所谓_1的位置在哪)，_2 为第二个参数，以此类推。_1/_2/_3.... 这些占位符放在 placeholders 的一个命名空间中。

#include <iostream>
#include <functional>// 定义一个减法函数，返回 (a - b) * 10
int Sub(int a, int b) {return (a - b) * 10;
}// 定义一个减法函数，返回 (a - b - c) * 10
int SubX(int a, int b, int c) {return (a - b - c) * 10;
}// 定义一个 Plus 类，包含静态和非静态的加法函数
class Plus {
public:// 静态加法函数static int plusi(int a, int b) {return a + b;}// 非静态加法函数double plusd(double a, double b) {return a + b;}
};int main() {// 使用 std::placeholders 命名空间中的占位符using namespace std::placeholders;// 绑定 Sub 函数，正常顺序传递参数auto sub1 = std::bind(Sub, _1, _2);std::cout << sub1(10, 5) << std::endl;// 调整参数顺序，交换 _1 和 _2 的位置auto sub2 = std::bind(Sub, _2, _1);std::cout << sub2(10, 5) << std::endl;// 调整参数个数，固定第一个参数为 100auto sub3 = std::bind(Sub, 100, _1);std::cout << sub3(5) << std::endl;// 调整参数个数，固定第二个参数为 100auto sub4 = std::bind(Sub, _1, 100);std::cout << sub4(5) << std::endl;// 分别绑死 SubX 函数的第 1、2、3 个参数auto sub5 = std::bind(SubX, 100, _1, _2);std::cout << sub5(5, 1) << std::endl;auto sub6 = std::bind(SubX, _1, 100, _2);std::cout << sub6(5, 1) << std::endl;auto sub7 = std::bind(SubX, _1, _2, 100);std::cout << sub7(5, 1) << std::endl;// 绑定 Plus 类的非静态成员函数std::function<double(Plus&&, double, double)> f6 = &Plus::plusd;Plus pd;std::cout << f6(std::move(pd), 1.1, 1.1) << std::endl;std::cout << f6(Plus(), 1.1, 1.1) << std::endl;// 使用 std::bind 绑定 Plus 类的非静态成员函数，固定对象std::function<double(double, double)> f7 = std::bind(&Plus::plusd, Plus(), _1, _2);std::cout << f7(1.1, 1.1) << std::endl;// 定义一个计算复利的 lambda 函数auto func1 = [](double rate, double money, int year) -> double {double ret = money;for (int i = 0; i < year; i++) {ret += ret * rate;}return ret - money;};// 绑死一些参数，实现支持不同年利率、不同金额和不同年份计算复利的结算利息std::function<double(double)> func3_1_5 = std::bind(func1, 0.015, _1, 3);std::function<double(double)> func5_1_5 = std::bind(func1, 0.015, _1, 5);std::function<double(double)> func10_2_5 = std::bind(func1, 0.025, _1, 10);std::function<double(double)> func20_3_5 = std::bind(func1, 0.035, _1, 30);std::cout << func3_1_5(1000000) << std::endl;std::cout << func5_1_5(1000000) << std::endl;std::cout << func10_2_5(1000000) << std::endl;std::cout << func20_3_5(1000000) << std::endl;return 0;
}