1. RVO优化和NRVO优化

从C++17开始，RVO优化强制使用，但NRVO优化并不强制使用。

我们以下面的类作为示例：

class TestO
{
    
public:
	TestObj()
	{
    
		std::cout << "调用构造函数" << std::endl;
	}
	TestObj(const TestObj& Obj) {
     
		std::cout << "调用拷贝构造函数 " << std::endl;
	}
	TestObj& operator=(const TestObj& obj) {
     

		std::cout << "调用赋值构造函数" << std::endl;
		return *this;
	}
	~TestObj() {
     
		std::cout << "调用析构函数" << std::endl;
	}
};

RVO优化：如果函数返回一个无名的临时对象，该对象将被编译器移动或拷贝到目标中，在此时，编译器可以优化代码以减少对象的构造，即省略拷贝或移动。

TestObj fun() 
{
    
	return TestObj();
}
int main()
{
    
	TestObj Obj = fun();
};

RVO优化结果如下：

NRVO优化：针对于一个命名的对象，仅适用不是函数参数的局部变量。

TestObj fun() {
    
	TestObj obj;
	return obj;
}

int main()
{
    
	TestObj Obj = fun();
};

NRVO优化结果如下：

2. 左值引用

2.1 左值引用的使用场景

1） 使用常量左值引用接收左值和右值

const int& i = 5;

注意：引用之后，“5的生命周期被延长”，语句结束后5右值被销毁，在i变量处开辟内存并存入5值。

/** 拷贝构造函数 */
TestObj(const TestObj& Obj) 
{
     
	std::cout << "调用拷贝构造函数 " << std::endl;
}
/** 赋值构造函数 */
TestObj& operator=(const TestObj& obj) 
{
     
	std::cout << "调用赋值构造函数" << std::endl;
	return *this;
}

在拷贝构造函数中使用const T&即能接收左值，也能接收临时变量返回的值。

注意：
（1）此处如果不加const，传入临时变量还是没有报错的话，是发生了上述的RVO优化，并没有发生拷贝构造函数。
（2）这种不安全的代码最好放在{}内部。

2）左值引用作为函数传参能减少拷贝构造函数的调用

TestObj f(TestObj& test)
{
    
	return test;
}

2.2 右值引用的使用场景

注意：含有移动语义的函数，如果在转移过程中抛出了异常，即对象的一部分转移了而一部分没有，这种情况是非常危险的，所有需要使用noexcpt说明符限制函数，程序会调用std::terminate中止执行，以免造成不良影响。

右值引用最大作用就是实现了移动语义，在拷贝大量内存的时候，提高了性能消耗并且减少了内存的空间碎片。

3. 值类别

3.1 引入将亡值的原因

首先我们先区分一下什么是亡值和纯右值：

/** 亡值表达式 */
// 返回类型是对象的右值引用的函数调用
// 无条件转换为亡值表达式
f(std::move(p));
// 强制转换到对象的右值引用类型的转换表达式
f(static_cast<int&&>(p));

/** 纯右值表达式 */
// 常量
f(50);
true;
nullptr;
// 取地址表达式
this;
f(&a);
// lambda表达式
f([] {
    return 1; } ());
// 数字运算表达式
int a; int b;
f(a + b);
f(a & b);

产生将亡值的途径有两种：
（1）使用强制类型转化，将泛左值转化为纯右值。
（2）临时量实质化，如下例子，X()是一个纯右值，而访问成员变量a需要一个泛左值，因此将X()转化为临时变量将亡值，才能访问其成员变量a。

struct X
{
    
	int a;
};
int main()
{
    
	int b = X().a;
};

需要注意c++17后才强制此概念，我们使用汇编对c++14和c++17进行区别，我们不开启RVO优化，结果如下所示：

可以发现C++17少了两次拷贝构造，因为函数返回的是纯右值，而不需要对其进行实质化，那么在返回时并不会调用其拷贝构造。将亡值可以看作一个连接左右值的中间变量，使得只有当程序用到该纯右值时才会将其实质化，这使得我们的程序更加的聪明，这就是C++17中要引入将亡值和纯右值来区分右值的原因。

3.2 左值转化为右值

问：左值怎么转化为右值，其应用场景是什么？

int a = 14;
int&& b= static_cast<int&&>(a);

注意：此处虽然将左值转化为将亡值，但是不是纯右值，因此有着之前相同的生命周期和内存地址。

在一个函数体内部，用一个右值引用作为参数，但在这个函数体内它是左值，这时就需要用到强制转化。

void f(TestObj&& i)
{
    
	// i虽然用一个右值引用接收，但在这个函数体内部它是左值
	// 调用拷贝构造函数
	TestObj obj(i);
}

int main()
{
    
	f(TestObj());
};

上述调用了拷贝构造函数，但这并不是我们所期望的结果，i虽然是左值但是之后就没有用了，我们的希望还是将其进行转移。

void f(TestObj&& i)
{
    
	// i虽然用一个右值引用接收，但在这个函数体内部它是左值
	// 虽然是左值，但是该左值是没有什么意义的
	// 因此将其转化为亡值，发生转移，同时i的原本地址也是没有任何意义了
	TestObj obj(static_cast<TestObj&&>(i));
}

int main()
{
    
	f(TestObj());
};

3.3 万能引用

/** 模板中的万能引用 */
template<class T>
void f(T&& t) 
{
    

}
/** auto */
auto&& i;

万能引用的引用折叠规则如下：

类型模板	T实际类型	最终类型
T&	R	R&
T&	R&	R&
T&	R&&	R&
T&&	R	R&&
T&&	R&	R&
T&&	R&&	R&&

可以发现：如果模板为T&，接收的永远为左值引用，如果是T&&，则就是万能引用。

3.4 可隐式移动优化

TestObj f(TestObj&& test)
{
    
	return test;
}

int main()
{
    
	TestObj test = f(TestObj());
};

在C++20之前，由于test在函数体中是左值，所以会调用移动构造函数；而C++20中在此处进行了优化。
定义了可隐式移动对象：
（1）可隐式移动对象是一个非易失或者右值引用的非易失自动存储的对象，
（2）是return返回、lambda表达式中的对象
（3）throw中抛出的对象。

下面也可以看到C++17与C++20对上述代码的区别。

4. forward与move

/** forward源码 */
template <class _Ty>
_NODISCARD constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept 
{
     // forward an rvalue as an rvalue
    static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
    // 使用万能引用的引用折叠将T原本的类型返回
    return static_cast<_Ty&&>(_Arg);
}

/** move源码 */
template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept 
{
     // forward _Arg as movable
	// remove_reference_t<_Ty>强制将引用删除，强制返回T&&类型
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

区别：
（1）两者都使用了static_cast<_Ty&&>对类型进行强制转化。
（2）forward类似于转发的功能，返回的是一个万能引用；而move强制将所有类型都转化为亡值类别。