目录
- C++11新特性
- 右值引用和移动语义
- 左值 / 右值
- 常见的左值和右值
- 移动语义
- 移动构造函数
- 移动复制运算符
- 完美转发
- Lambda 表达式详解
- Lambda 表达式
- Lambda 表达式语法
- 函数对象与lambda表达式
- 总结
C++11新特性
右值引用和移动语义
传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。那么什么是左值？什么是左值引用？
左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。
左值 / 右值
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
右值引用就是对右值的引用，给右值取别名。
右值引用特性:
语法：Type&& 变量名= 值;
目的：
识别并利用临时对象的资编程源：避免不必要的深拷贝。
实现移动语义：转移资源所有权而非复制。
完美转发：在模板中保持参数的值类别。
std::move()：将左值转为右值std::forward()：完美转发参数
左值：有名称、有地址、可被取地址的持久对象
int main(){
int* p = new int(0); // 以下的p、b、c、*p都是左值
int b = 1;javascript // b 是左值，1是右值
int *ptr=&b; // 可以取b的地址，说明b是左值
const int c = 2;
int*& rp = p; // 以下几个是对上面左值的左值引用
int& rb = b;
const int& rc = c;
int& pvalue = *p;
return 0;}
右值 ： 临时对象、字面量、即将销毁的对象
std::move(x); // 返回右值引用
double x = 1.1, y = 2.2;
10; // 字面量是右值
x + y; // 表达式结果是右值
fmin(x, y); //函数
// 以下几个都是对右值的右值引用
int&& rr1 = 10; // 右值引用绑定到字面量（右值）
int& err = 42; // 错误：左值引用不能直接绑定到右值
double&& rr2 = x + y;// x+y是右值（临时计算结果）
double&& rr3 = fmin(x, y);
// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
10 = 1;
x + y = 1;
fmin(x, y) = 1;
常见的左值和右值
左值示例：
- 变量名：
int x; 中的 x - 函数返回的左值引用：
std::getline()返回的std::istream& - 数组元素：
arr[0] - 解引用指针：
*ptr
右值示例：
- 字面量：
42,true - 临时对象：
std::string("temp") - 表达式结果：
x + 1,func()（如果func()返回值类型） - 将亡值：
std::move(x)返回的右值引用
int a = 10; // 左值引用 引用 左值 int& ra = a; // 右值引用 引用 右值 int&& rr = 10;
需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。
如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。
int main(){
double x = 1.1, y = 2.2;
int&& rr1 = 10;
const double&& rr2 = x + y;
rr1 = 20;
rr2 = 5.5; // 报错
return 0;
}
移动语义
移动语义允许将资源（如动态分配的内存）从一个对象转移到另一个对象，而无需进行深拷贝，从而显著提高性能。
移动构造函数
移动构造函数接受一个右值引用作为参数，用于从临时对象中 “转移” 资源。
// 移动构造函数
Date(Date&& other) noexcept
: year(other.year), month(other.month), day(other.day) {
other.year = nullptr; // 转移资源所有权
std::cout << "移动构造: " << (year ? *year : 0)
<< "-" << month << "-" <<编程客栈; day << std::endl;
}
移动复制运算符
移动赋值运算符用于从右值对象转移资源。
// 移动赋值运算符
Date& operator=(Date&& other) noexcept {
if (this != &other) {
delete year; // 释放当前资源
year = other.year; // 转移资源
month = other.month;
day = other.day;
other.year = nullptr; // 重置源对象
}
std::cout << "移动赋值: " << (year ? *year : 0)
<< "-" << month << "-" << day << std::endl;
return *this;
}
move
将一个左值强制转换为右值引用，从而可以调用移动语义。
Date d1(1,2,3); Date d2= std::move(d1); // 调用移动构造函数 // 注意：d1的资源已被转移，此时d1处于有效但未指定的状态
完美转发
完美转发允许函数模板将参数以原始的值类别转发给其他函数，避免不必要的拷贝或转换。
万能引用与forward
在模板中，使用T&&声明的参数可以绑定到任何类型的参数（左值或右值）。forward在转发过程中保持参数的原始值类别。
template<typename T>
void func1(T&& arg) {
// 如果arg是右值，转发为右值；如果是左值，转发为左值
func2(std::forward<T>(arg));
}
// 示例调用
void func(int& x) { std::cout << "左值" << std::endl; }
void func(int&& x) { std::cout << "右值" << std::endl; }
int main() {
int x = 10;
func1(x); // 转发为左值，调用func(int&)
func1(20); // 转发为右值，调用func(int&&)
return 0;
}
完整代码:
class Date {
public:
// 默认构造函数
Date(int y = 2000, int m = 1, int d = 1)
: year(new int(y)), month(m), day(d) {
std::cout << "构造: " << *year << "-" << month << "-" << day << std::endl;
}
// 拷贝构造函数
Date(const Date& other)
: year(new int(*other.year)), month(other.month), day(other.day) {
std::cout << "拷贝构造: " << *year << "-" << month << "-" << day << std::endl;
}
// 释放原对象的资源，防止析构时重复释放
Date(Date&& other) noexcept
: year(other.year), month(other.month), day(other.day) {
javascript other.year = nullptr; // 转移资源所有权
std::cout << "移动构造: " << (year ? *year : 0) << "-" << month << "-" << day << std::endl;
}
// 拷贝赋值运算符
Date& operator=(const Date& other) {
if (this != &other) {
delete year;
year = new int(*other.year);
month = other.month;
phpday = other.day;
}
std::cout << "拷贝赋值: " << *year << "-" << month << "-" << day << std::endl;
return *this;
}
// 移动赋值运算符
Date& operator=(Date&& other) noexcept {
if (this != &other) {
delete year; // 释放当前资源
year = other.year; // 转移资源
month = other.month;
day = other.day;
other.year = nullptr; // 重置源对象
}
std::cout << "移动赋值: " << (year ? *year : 0) << "-" << month << "-" << day << std::endl;
return *this;
}
// 析构函数
~Date() {
delete year;
std::cout << "析构: " << (year ? *year : 0) << "-" << month << "-" << day << std::endl;
}
// 获取日期字符串
std::string toString() const {
return year ?
std::to_string(*year) + "-" + std::to_string(month) + "-" + std::to_string(day) :
"invalid date";
}
private:
int* year; // 动态分配资源
int month;
int day;
};
// 完美转发示例
template<typename T>
void setDate(T&& date) {
Date storage = std::forward<T>(date); // 保持原始值类别
std::cout << "存储日期: " << storage.toString() << std::endl;
}
int main() {
// 移动构造示例
Date d1(2025, 10, 1);
Date d2(std::move(d1)); // 调用移动构造函数
std::cout << "d1: " << d1.toString() << std::endl; // 输出: invalid date
std::cout << "d2: " << d2.toString() << std::endl; // 输出: 2023-10-1
// 移动赋值示例
Date d3(2025, 1, 1);
d2 = std::move(d3); // 调用移动赋值运算符
std::cout << "d2: " << d2.toString() << std::endl; // 输出: 2024-1-1
std::cout << "d3: " << d3.toString() << std::endl; // 输出: invalid date
// 完美转发示例
Date d4(2025, 5, 15);
setDate(d4); // 左值参数，调用拷贝构造
setDate(Date(2025, 10, 1)); // 右值参数，调用移动构造
return 0;
}
Lambda 表达式详解
随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法， 都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。
Lambda 表达式
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
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; });
}
上述代码就是使用C++11中的lambda表达式来解决，可以看出lambda表达式实际是一个匿名函数。
Lambda 表达式语法
[capture-list](parameters) mutable -> return-type { body }
- 捕获列表 (capture-list)：定义外部变量的访问方式
- 参数列表 (parameters)：与普通函数参数类似
- mutable 修饰符：允许修改按值捕获的变量
- 返回类型 (return-type)：可显式声明或自动推导
- 函数体 (body)：包含实际执行的代码
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[]{};
// 省略参数列表和返回值类型，返回值类型由编译器推导为int
int a = 3, b = 4;
[=]{return a + 3; };
// 省略了返回值类型，无返回值类型
auto fun1 = [&](int c){b = a + c; };
fun1(10)
cout<<a<<" "<<b<<endl;
}
通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。
捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
- [var]：表示值传递方式捕捉变量var
- [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
- [&var]：表示引用传递捕捉变量var
- [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
- [this]：表示值传递方式捕捉当前的this指针
注意：
父作用域定义
- 指包含 lambda 函数的语句块（局部作用域）
捕获列表语法
- 多捕获项用逗号分隔
禁止重复捕获
- 非局部作用域限制
- 全局/命名空间作用域的 lambda 捕获列表必须为空
局部变量捕获限制
- 只能捕获父作用域的局部变量或
this - 禁止捕获类成员变量（除非通过
this）
Lambda对象唯一性
- 每个lambda表达式生成唯一类型
- 禁止同类型lambda相互赋值（即使捕获方式相同）
函数对象与lambda表达式
函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。
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;
Rate r1(rate);
r1(10000, 2);
// lamber
auto r2 = [=](double monty, int year)->double{return monty*rate*year;
};
r2(10000, 2);
return 0
从使用方式上来看，函数对象与lambda表达式完全一样。
函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。
总结
以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。
![解决Kibana报错[security_exception] current license is non-compliant for [security]问题](https://www.devze.com/res/2025/07-29/10/995e7fc1933662ed9d4eb866cebacfc8.jpg)
加载中,请稍侯......
精彩评论