当前位置： 首页 > news >正文

【C++】C++11（二）

news 2025/9/21 8:25:22

4. 可变参数模板

4.1 基本语法及原理

  • C++11支持可变参数模板，也就是说支持可变数量参数的函数模板和类模板，可变数量的参数被称 为参数包，存在两种参数包：模板参数包，表示零或多个模板参数；函数参数包：表示零或多个函 数参数
  • 用省略号来表示一个模板参数或函数参数的包，在模板参数列表中，class...或 typename...表示接下来的参数包是一个零或多个类型的列表；在函数参数列表中，类型名后面跟 ... 表示接下来的参数包是一个零或多个形参对象的列表
  • 函数参数包可以用左值引用或右值引用表示，跟普通模板一样，每个参数实例化时遵循引用折叠规则
  • 可以使用sizeof...运算符去计算参数包中参数的个数
template <class ...Args>
void Print(Args&&... args)
{cout << sizeof...(args) << endl;
}

4.2 包扩展

  • 对于一个参数包，除了能计算他的参数个数，还可以扩展它，当扩展一个包时，要提供用于每个扩展元素的模式，扩展一个包就是将它分解为构成的元素，对每个元素应用模式，获得扩展后的列表。我们通过在模式的右边放一个省略号(...)来触发扩展操作。底层的实现细节如图1
  • C++还支持更复杂的包扩展，直接将参数包依次展开依次作为实参给一个函数去处理
图1
void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}void ShowList()
{// 编译器时递归的终⽌条件，参数包是0个时，直接匹配这个函数 cout << endl;
}
template <class T, class ...Args>
void ShowList(T x, Args... args)
{cout << x << " ";// args是N个参数的参数包 // 调⽤ShowList，参数包的第⼀个传给x，剩下N-1传给第⼆个参数包 ShowList(args...);
}
// 编译时递归推导解析参数 
template <class ...Args>
void Print(Args... args)
{ShowList(args...);
}
int main()
{Print();Print(1);Print(1, string("xxxxx"));Print(1, string("xxxxx"), 2.2);return 0;
}
//template <class T, class ...Args>
//void ShowList(T x, Args... args)
//{
// cout << x << " ";
// Print(args...);
//}
// Print(1, string("xxxxx"), 2.2);调⽤时 
// 本质编译器将可变参数模板通过模式的包扩展，编译器推导的以下三个重载函数函数 
//void ShowList(double x)
//{
// cout << x << " ";
// ShowList();
//}
//
//void ShowList(string x, double z)
//{
// cout << x << " ";
// ShowList(z);
//}
//
//void ShowList(int x, string y, double z)
//{
// cout << x << " ";
// ShowList(y, z);
//}
//void Print(int x, string y, double z)
//{
// ShowList(x, y, z);
//}

4.3 empalce系列接口

  • C++11以后STL容器新增了empalce系列的接口，empalce系列的接口均为模板可变参数，功能上 兼容push和insert系列，但是empalce还支持新玩法，假设容器为container，empalce还支持直接插⼊构造T对象的参数，这样有些场景会更高效，可以直接在容器空间上构造T对象
  • emplace_back总体高效，推荐使用emplace系列替代insert和push系列
  • 模拟实现了list的emplace和emplace_back接口，这里把参数包不段往下传递， 最终在结点的构造中直接去匹配容器存储的数据类型T的构造，所以达到了前⾯说的empalce支持直接插入构造T对象的参数，这样有些场景会更高效，可以直接在容器空间上构造T对象
  • 传递参数包过程中，如果是 Args&&... args 的参数包，要用完美转发参数包，方式如下 ，否则编译时包扩展后右值引用变量表达式就变成了左值

5. 新的类功能

5.1 默认的移动构造和移动赋值

  • 原来C++类中，有6个默认成员函数：构造函数/析构函数/拷贝构造函数/拷贝赋值重载/取地址重 载/const取地址重载，最后重要的是前4个，默认成员函数就是我们不写编译器会生成一个默认的。C++11新增了两个默认成员函数，移动构造函数和移动赋值运算符重载
  • 如果你没有自己实现移动构造函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。
  • 默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调永移动构造，没有实现就调用拷贝构造
  • 如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意 一个，那么编译器会自动生成一个默认移动赋值。
  • 默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
  • 如果提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值

5.2 成员变量声明时给缺省值

成员变量声明时给缺省值是给初始化列表用的，如果没有显示在初始化列表初始化，就会在初始化列表用这个缺省值初始化

5.3 defult和delete

假设要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成

想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁已， 这样只要其他⼈想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数

class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p):_name(p._name), _age(p._age){}Person(Person&& p) = default;//Person(const Person& p) = delete;
private:string _name;int _age;
};
int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}

5.4 final与override

参考多态章节

6. STL中一些变化

圈起来的是STL中的新容器

7. lambda

7.1 lambda表达式语法

  • lambda 表达式本质是一个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。 lambda 表达式语法使用层而言没有类型，一般是用auto或者模板参数定义的对象去接收lambda对象
  • lambda表达式的格式：
  • ：捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据[ ]来 判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用，捕捉列表可以传值和传引用捕捉，捕捉列表为空也不能省略
  • ：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同()⼀起省略
  • ：返回值类型，用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。一般返回值类型明确情况下，也可省略，由编译器对返回类型进行推导
  • ：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，函数体为空也不能省略
// ⼀个简单的lambda表达式 auto add1 = [](int x, int y)->int {return x + y; };
cout << add1(1, 2) << endl;
// 1、捕捉为空也不能省略 
// 2、参数为空可以省略 
// 3、返回值可以省略，可以通过返回对象⾃动推导 
// 4、函数题不能省略

7.2 捕捉列表

  • lambda表达式中默认只能用lambda函数体和参数中的变量，如果想用外层作用域中的变量就需要进行捕捉 
  • 第一种捕捉方式是在捕捉列表中显示的传值捕捉和传引用捕捉，捕捉的多个变量用逗号分割。[x， y，&z]表示x和y值捕捉，z引用捕捉
  • 第二种捕捉方式是在捕捉列表中隐式捕捉，我们在捕捉列表写一个=表示隐式值捕捉，在捕捉列表 写一个&表示隐式引用捕捉，这样我们 lambda 表达式中用了那些变量，编译器就会自动捕捉那些 变量
  • 第三种捕捉方式是在捕捉列表中混合使用隐式捕捉和显示捕捉。[=,&x]表示其他变量隐式值捕捉， x引用捕捉；[&, x, y]表示其他变量引用捕捉，x和y值捕捉。当使用混合捕捉时，第一个元素必须是 &或=，并且&混合捕捉时，后面的捕捉变量必须是值捕捉，同理=混合捕捉时，后面的捕捉变量必 须是引用捕捉
int x = 0;
// 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量 
auto func1 = [](){x++;};
int main()
{// 只能⽤当前lambda局部域和捕捉的对象和全局对象 int a = 0, b = 1, c = 2, d = 3;auto func1 = [a, &b]{// 值捕捉的变量不能修改，引⽤捕捉的变量可以修改 //a++;b++;int ret = a + b;return ret;};cout << func1() << endl;// 隐式值捕捉 // ⽤了哪些变量就捕捉哪些变量 auto func2 = [=]{int ret = a + b + c;return ret;};cout << func2() << endl;// 隐式引⽤捕捉 // ⽤了哪些变量就捕捉哪些变量 auto func3 = [&]{a++;c++;d++;};func3();cout << a << " " << b << " " << c << " " << d << endl;// 混合捕捉1 auto func4 = [&, a, b]{//a++;//b++;c++;d++;return a + b + c + d;};func4();cout << a << " " << b << " " << c << " " << d << endl;// 混合捕捉1 auto func5 = [=, &a, &b]{a++;b++;/*c++;d++;*/return a + b + c + d;};func5();cout << a << " " << b << " " << c << " " << d << endl;// 局部的静态和全局变量不能捕捉，也不需要捕捉 static int m = 0;auto func6 = []{int ret = x + m;return ret;};// 传值捕捉本质是⼀种拷⻉,并且被const修饰了 // mutable相当于去掉const属性，可以修改了 // 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉ auto func7 = [=]()mutable{a++;b++;c++;d++;return a + b + c + d;};cout << func7() << endl;cout << a << " " << b << " " << c << " " << d << endl;return 0;
}

7.3 lambda的应用

函数指针的类型定义起来比较麻烦，仿函数要定义一个类，相对会比较麻烦。可使用lambda去定义可调用对象

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 } };// 类似这样的场景，我们实现仿函数对象或者函数指针支持商品中 // 仿函数则需要实现operator()函数来实现比较// 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;
}

8. 包装器

8.1 function

template <class T>
class function; // undefinedtemplate <class Ret, class... Args>
class function<Ret(Args...)>;

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

以上是 function 的原型，他被定义<functional>头文件中

函数指针、仿函数、 lambda 等可调用对象的类型各不相同， std::function 的优势就是统一类型，对他们都可以进行包装，这样在很多地方就方便声明可调用对象的类型

int main()
{// 包装各种可调⽤对象 function<int(int, int)> f1 = f;function<int(int, int)> f2 = Functor();function<int(int, int)> f3 = [](int a, int b) {return a + b; };cout << f1(1, 1) << endl;cout << f2(1, 1) << endl;cout << f3(1, 1) << endl;// 包装静态成员函数 // 成员函数要指定类域并且前⾯加&才能获取地址 function<int(int, int)> f4 = &Plus::plusi;cout << f4(1, 1) << endl;// 包装普通成员函数 // 普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以 function<double(Plus*, double, double)> f5 = &Plus::plusd;Plus pd;cout << f5(&pd, 1.1, 1.1) << endl;function<double(Plus, double, double)> f6 = &Plus::plusd;cout << f6(pd, 1.1, 1.1) << endl;cout << f6(pd, 1.1, 1.1) << endl;function<double(Plus&&, double, double)> f7 = &Plus::plusd;cout << f7(move(pd), 1.1, 1.1) << endl;cout << f7(Plus(), 1.1, 1.1) << endl;return 0;
}

8.2 bind

simple(1)
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);with return type(2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn && fn, Args&&... args);
  • bind 是一个函数模板，它也是一个可调用对象的包装器，可以把他看做一个函数适配器，对接收 的fn可调用对象进行处理后返回一个可调用对象。 bind 可以用来调整参数个数和参数顺序。 bind 也在这个<functional>头文件中
  • 调用bind的一般形式：其中 newCallable本身是一个可调用对象，arg_list是⼀个逗号分隔的参数列表，对应给定的callable的 参数。当我们调用newCallable时，newCallable会调用callable，并传给它arg_list中的参数
  • arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是占位符，表示newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表示生成的可调用对象 中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。_1/_2/_3....这些占 位符放到placeholders的一个命名空间中
#include<functional>
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int Sub(int a, int b)
{return (a - b) * 10;
}
int SubX(int a, int b, int c)
{return (a - b - c) * 10;
}
class Plus
{
public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;}
};
int main()
{auto sub1 = bind(Sub, _1, _2);cout << sub1(10, 5) << endl;// bind 本质返回的⼀个仿函数对象 // 调整参数顺序（不常⽤） // _1代表第⼀个实参 // _2代表第⼆个实参 // ...auto sub2 = bind(Sub, _2, _1);cout << sub2(10, 5) << endl;// 调整参数个数 （常⽤） auto sub3 = bind(Sub, 100, _1);cout << sub3(5) << endl;auto sub4 = bind(Sub, _1, 100);cout << sub4(5) << endl;// 分别绑死第123个参数 auto sub5 = bind(SubX, 100, _1, _2);cout << sub5(5, 1) << endl;auto sub6 = bind(SubX, _1, 100, _2);cout << sub6(5, 1) << endl;auto sub7 = bind(SubX, _1, _2, 100);cout << sub7(5, 1) << endl;// 成员函数对象进⾏绑死，就不需要每次都传递了 function<double(Plus&&, double, double)> f6 = &Plus::plusd;Plus pd;cout << f6(move(pd), 1.1, 1.1) << endl;cout << f6(Plus(), 1.1, 1.1) << endl;// bind⼀般⽤于，绑死⼀些固定参数 function<double(double, double)> f7 = bind(&Plus::plusd, Plus(), _1, _2);cout << f7(1.1, 1.1) << 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;};// 绑死⼀些参数，实现出⽀持不同年华利率，不同⾦额和不同年份计算出复利的结算利息 function<double(double)> func3_1_5 = bind(func1, 0.015, _1, 3);function<double(double)> func5_1_5 = bind(func1, 0.015, _1, 5);function<double(double)> func10_2_5 = bind(func1, 0.025, _1, 10);function<double(double)> func20_3_5 = bind(func1, 0.035, _1, 30);cout << func3_1_5(1000000) << endl;cout << func5_1_5(1000000) << endl;cout << func10_2_5(1000000) << endl;cout << func20_3_5(1000000) << endl;return 0;
}

9. 智能指针

http://www.dtcms.com/a/392801.html

相关文章：

  • 如何解决 pip install 安装报错 ModuleNotFoundError: No module named ‘selenium’ 问题
  • 实测美团LongCat-Flash：当大模型装上“速度引擎”，能否改写智能体战局？
  • unicode ascii utf-8的区别
  • Rust_2025：阶段1：day6.1 collect补充 ,迭代器补充 ，闭包，Hashmap搜索指定值的个数，合并迭代器
  • ESP32- 项目应用2 音乐播放器之音响驱动 #2
  • Datawhale25年9月组队学习：llm-preview+Task2：大模型使用
  • Agent记忆：Memvid、Memary、MemoryOS
  • 《主流PLC品牌型号大全解析》，电气设计时PLC应该怎么选
  • 从92到102，一建实务突破之路：坚持与自我超越
  • 探索C语言中字符串长度的计算方法
  • 使用node框架 Express开发仓库管理系统练习项目
  • 网络系统管理
  • 【Vue3 ✨】Vue3 入门之旅 · 第四篇：组件的创建与传递数据
  • PHP魔法函数和超全局数组介绍——第一阶段
  • 深入剖析“惊群效应”：从Java的notifyAll到epoll的解决方案
  • 鸿蒙应用统一埋点体系设计
  • Rust_2025：阶段1：day6.2 Box ，Cow ，Rc ，Refcell ，Arc，线程(join（），lock（），子线程与主线程通信
  • GD32VW553-IOT V2【微秒延迟时间实现方法】
  • html5是移动设备玖写口吧目盖由
  • 华为全联接大会 2025：跃升行业智能化
  • 采用Mayavi对BEV相机外参进行可视化
  • 算法高频题-动态规划
  • 第七篇：强类型枚举：enum class - 彻底解决传统枚举的缺陷
  • 汽车中的轻量化 AI 算法：驶向智能出行新未来
  • 《根治开放世界坐骑卡顿：从时钟同步到负载均衡的架构级解决方案》
  • 在线预览Office文件全攻略
  • Cordova打包Vue项目成APK——真机调试
  • DNS协议、ICMP协议、NAT技术
  • HTML5 基础与常用标签
  • 2023 CCPC Online vp补题-D