C++11右值引用与Lambda表达式的使用

本文主要是介绍C++11右值引用与Lambda表达式的使用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《C++11右值引用与Lambda表达式的使用》C++11引入右值引用,实现移动语义提升性能,支持资源转移与完美转发；同时引入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) 返回的右值引用

C++11右值引用与Lambda表达式的使用

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 << "-" <<China编程; 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表达式通过捕获列表可以直接将该变量捕获到。

C++11右值引用与Lambda表达式的使用