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

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;
}

#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;
}

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

auto il = { 10, 20, 30 };  // the type of il is an 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;
}

[capture-list] (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;
}

#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;
}

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;
}

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)  

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

#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;
}