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

C++：现代 C++ 编程基石，C++11核心特性解析与实践

news 2025/7/17 7:14:24

一.列表初始化{ }

二.initializer_list

三. 右值引用和移动语义

一）.左值和右值

二）.左值引用和右值引用

三）.引用延长生命周期

四）.左值和右值的参数匹配

五）.右值引用和移动语义的使用场景

1.左值引用主要使用场景

2.移动构造和移动赋值

3.右值引用和移动语义解决传值返回

4 右值引用和移动语义在传参中的提效

六）.左值右值类型分类

七）.引用折叠

八）.完美转发

四.可变参数模板

一）.基本语法及原理

二）.包扩展

五.新的类功能

一）.默认的移动构造和移动赋值

二）.defult和delete

六.lambda

一）.lambda表达式语法

二）.捕捉列表

三）.lambda的应用

七.包装器

一）.function

二）.bind

八.const限定符

九.处理类型

一）.auto

一.列表初始化{ }

C++11以后想统一初始化方式，试图实现一切对象皆可用{}初始化，{}初始化也叫做列表初始化。(注意，不是初始化列表)
内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，最后优化了以后变成直接构造。
{}初始化的过程中，可以省略掉=
C++11列表初始化的本意是想实现一个大统一的初始化方式，其次他在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很方便

//日期类代码#include<iostream>
#include<vector>
using namespace std;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()
{// 自定义类型⽀持// 这里本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象// 临时对象再去拷贝构造d1，编译器优化后合二为一变成{ 2025, 1, 1}直接构造初始化d1Date d1 = { 2025, 1, 1 };// 这⾥d2引用的是{ 2024, 7, 25 }构造的临时对象const Date& d2 = { 2024, 7, 25 };// 可以省略掉=Date d3{ 2024, 7, 25 };const Date& d4{ 2024, 7, 25 };// ⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐vector<Date> v;v.push_back({ 2025, 1, 1 });return 0;
}

二.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 }; // thetype of il is an initializer_list ，这个类的本质是底层开一个数组，将数据拷贝过来，std::initializer_list内部有两个指针分别指向数组的开始和结束
容器支持一个std::initializer_list的构造函数，也就支持任意多个值构成的 {x1,x2,x3...} 进行初始化。STL中的容器支持任意多个值构成的 {x1,x2,x3...} 进行初始化，就是通过std::initializer_list的构造函数支持的

// STL中的容器都增加了⼀个initializer_list的构造vector(initializer_list<value_type> il, const allocator_type& alloc =allocator_type());
list(initializer_list<value_type> il, const allocator_type& alloc =allocator_type());
map(initializer_list<value_type> il, const key_compare& comp =key_compare(), const allocator_type& alloc = allocator_type());
// ...

template<class T>
class vector {
public:typedef T* iterator;vector(initializer_list<T> l)  //实现了initializer_list构造函数{for (auto e : l)push_back(e)}
private:iterator _start = nullptr;iterator _finish = nullptr;iterator _endofstorage = nullptr;
};

int main()
{// {}列表中可以有任意多个值// 这两个写法语义上还是有差别的，第?个v1是直接构造，// 第?个v2是构造临时对象+临时对象拷?v2+优化为直接构造vector<int> v1({ 1,2,3,4,5 });vector<int> v2 = { 1,2,3,4,5 };const vector<int>& v3 = { 1,2,3,4,5 };//这里是pair对象的{}初始化和map的initializer_list构造结合到?起用了map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };return 0;
}

三. 右值引用和移动语义

C++98的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，C++11之后我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名

一）.左值和右值

左值是一个表示数据的表达式(如变量名或解引用的指针)，一般是有持久状态，存储在内存中，我们可以获取它的地址，左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。
右值也是一个表示数据的表达式，要么是字面值常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
值得一提的是，左值的英文简写为lvalue，右值的英文简写为rvalue。传统认为它们分别是left value、right value 的缩写。现代C++中，lvalue 被解释为loactor value的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象，而rvalue 被解释为 read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字面量常量，存储于寄存器中的变量等，也就是说左值和右值的核心区别就是能否取地址。

左值：

int main()
{// 左值：可以取地址// 以下的p、b、c、*p、s、s[0]就是常见的左值int* p = new int(0);int b = 1;const int c = b;*p = 10;string s("111111");s[0] = 'x';cout << &c << endl;cout << (void*)&s[0] << endl;return 0;
}

右值：

int main()
{// 右值：不能取地址double x = 1.1, y = 2.2;// 以下几个10、x + y、fmin(x, y)、string("11111")都是常见的右值10;x + y;fmin(x, y);string("11111");//cout << &10 << endl;  //无法取地址//cout << &(x+y) << endl;//cout << &(fmin(x, y)) << endl;//cout << &string("11111") << endl;}

二）.左值引用和右值引用

左值引用就是给左值取别名，同样的道理，右值引用就是给右值取别名。
左值引用不能直接引用右值，但是const左值引用可以引用右值。右值引用不能直接引用左值，但是右值引用可以引用move(左值)。
move是库里面的一个函数模板，本质内部是进行强制类型转换，当然他还涉及一些引用折叠的知识。
需要注意的是变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量变量表达式的属性是左值。
语法层面看，左值引用和右值引用都是取别名，不开空间。从汇编底层的角度看，底层都是用指针实现的，没什么区别。底层汇编等实现和上层语法表达的意义有时是背离的，所以不要混到一起去理解，互相佐证，这样反而是陷入迷途。

左值引用：

int main()
{//左值引用给左值取别名int& r1 = b;int*& r2 = p;int& r3 = *p;string& r4 = s;char& r5 = s[0];
}

右值引用：

int main()
{// 右值引用给右值取别名int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y);string&& rr4 = string("11111");
}

	// 左值引用不能直接引用右值，但是const左值引用可以引用右值const int& rx1 = 10;const double& rx2 = x + y;const double& rx3 = fmin(x, y);const string& rx4 = string("11111");// 右值引用不能直接引用左值，但是右值引用可以引用move(左值)int&& rrx1 = move(b);int* && rrx2 = move(p);int&& rrx3 = move(*p);string&& rrx4 = move(s);string&& rrx5 = (string&&)s;//本质是类型转换int&& rr1 = 10;// 这里要注意的是，rr1的属性是左值，所以不能再被右值引用绑定，除非move一下int& r6 = rr1;//int&& rr6 = rr1;  //错误int&& rr6 = move(rr1);

三）.引用延长生命周期

右值引用可用于为临时对象延长生命周期，const 的左值引用也能延长临时对象生存期，但这些对象无法被修改。

int main()
{std::string s1 = "Test";// std::string&& r1 = s1;           // 错误：不能绑定到左值const std::string& r2 = s1 + s1;    // OK：到 const 的左值引用延长⽣存期// r2 += "Test";                   // 错误：不能通过到 const 的引用修改std::string&& r3 = s1 + s1;        // OK：右值引用延长⽣存期r3 += "Test";                      // OK：能通过到⾮ const 的引用修改std::cout << r3 << '\n';return 0;
}

四）.左值和右值的参数匹配

C++98中，我们实现⼀个const左值引用作为参数的函数，那么实参传递左值和右值都可以匹配
C++11以后，分别重载左值引用、const左值引用、右值引用作为形参的f函数，那么实参是左值会匹配f(左值引用)，实参是const左值会匹配f(const 左值引用)，实参是右值会匹配f(右值引用)。
右值引用变量在用于表达式时属性是左值

void f(int& x)
{std::cout << "左值引用重载 f(" << x << ")\n";
}
void f(const int& x)
{std::cout << "到 const 的左值引用重载 f(" << x << ")\n";
}
void f(int&& x)
{std::cout << "右值引用重载 f(" << x << ")\n";
}int main()
{int&& rr1 = 10;int a = 20;int& r2 = a;int i = 1;const int ci = 2;f(i); // 调用 f(int&)f(ci); // 调用 f(const int&)f(3); // 调用 f(int&&)，如果没有 f(int&&) 重载则会调用 f(const int&)f(std::move(i)); // 调用 f(int&&)// 右值引用变量在用于表达式时是左值// 右值引用本身的属性是左值int&& x = 1;f(x);   // 调用 f(int& x), x本身是左值f(std::move(x)); // 调用 f(int&& x)return 0; 
}

五）.右值引用和移动语义的使用场景

1.左值引用主要使用场景

左值引用主要使用场景是在函数中左值引用传参和左值引用传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。左值引用已经解决大多数场景的拷贝效率问题，但是有些场景不能使用传左值引用返回。那么C++11以后这里可以使用右值引用做返回值解决吗？显然是不可能的，因为这里的本质是返回对象是一个局部对象，函数结束这个对象就析构销毁了，右值引用返回也无法概念对象已经析构销毁的事实。

2.移动构造和移动赋值

移动构造函数是⼀种构造函数，类似拷贝构造函数，移动构造函数要求第一个参数是该类类型的引用，但是不同的是要求这个参数是右值引用，如果还有其他参数，额外的参数必须有缺省值。
移动赋值是一个赋值运算符的重载，他跟拷贝赋值构成函数重载，类似拷贝赋值函数，移动赋值函数要求第⼀个参数是该类类型的引用，但是不同的是要求这个参数是右值引用。
对于像string/vector这样的深拷贝的类或者包含深拷贝的成员变量的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第一个参数都是右值引勇的类型，他的本质是要“窃取”引用的右值对象的资源，而不是像拷贝构造和拷贝赋值那样去拷贝资源，从提高效率。

void swap(string& ss)
{::swap(_str, ss._str);::swap(_size, ss._size);::swap(_capacity, ss._capacity);
}//移动构造
string(string&& s)
{cout << "string(string&& s) -- 移动构造" << endl;// 转移掠夺你的资源swap(s);
}
// 移动赋值
string& operator=(string&& s)
{cout << "string& operator=(string&& s) -- 移动赋值" << endl;swap(s);return *this;
}

3.右值引用和移动语义解决传值返回

右值对象构造，只有拷贝构造，没有移动构造的场景

右值对象构造，有拷贝构造，也有移动构造的场景

当然，还有更进一步的优化

右值对象赋值，只有拷贝构造和拷贝赋值，没有移动构造和移动赋值的场景

右值对象赋值，既有拷贝构造和拷贝赋值，也有移动构造和移动赋值的场景

深拷贝的自定义类型：如vector/string/map.....实现移动构造和移动赋值是有很大价值的