编辑代码

#include <iostream>
using namespace std;
#include<list>
//    1. move
// 在 C++11 添加了右值引用，并且不能使用左值初始化右值引用，如果想要使用左值初始化一个右值引用需要借助 std::move () 函数，使用std::move方法可以将左值转换为右值。使用这个函数并不能移动任何东西，而是和移动构造函数一样都具有移动语义，将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存拷贝。

// 从实现上讲，std::move 基本等同于一个类型转换：static_cast<T&&>(lvalue);，函数原型如下:

// C++
// 1
// 2
// 3
// 4
// 5
// template<class _Ty>
// _NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) _NOEXCEPT
// {	// forward _Arg as movable
//     return (static_cast<remove_reference_t<_Ty>&&>(_Arg));
// }
// 使用方法如下：

//1.move

class Test
{
    public:
    Test(){}
};

void test()
{
    Test t;
    //Test &&v1=t; //err
    Test &&v2=move(t);  //ok 使用move()函数将左值转换为了右值，这样就可以初始化右值引用了。
    
    //假设一个临时容器很大，并且需要将这个容器赋值给另一个容器，则可以执行如下操作：
    list<string>ls;
    ls.push_back("hello");
    ls.push_back("world");
    //.....
    list<string>ls1=ls;  //需要拷贝，效率低。
    cout<<ls.size()<<endl;  //2
    list<string>ls2=move(ls);
    cout<<ls.size()<<endl; //0   资源都转移给ls2了。
}
//如果不使用 std::move，拷贝的代价很大，性能较低。使用 move 几乎没有任何代价，只是转换了资源的所有权。如果一个对象内部有较大的堆内存或者动态数组时，使用 move () 就可以非常方便的进行数据所有权的转移。另外，我们也可以给类编写相应的移动构造函数（T::T(T&& another)）和和具有移动语义的赋值函数（T&& T::operator=(T&& rhs)），在构造对象和赋值的时候尽可能的进行资源的重复利用，因为它们都是接收一个右值引用参数。


// 2. forward
// 右值引用类型是独立于值的，一个右值引用作为函数参数的形参时，在函数内部转发该参数给内部其他函数时，它就变成一个左值，并不是原来的类型了。如果需要按照参数原来的类型转发到另一个函数，可以使用 C++11 提供的 std::forward () 函数，该函数实现的功能称之为完美转发。

// C++
// 1
// 2
// 3
// 4
// 5
// 6
// // 函数原型
// template <class T> T&& forward (typename remove_reference<T>::type& t) noexcept;
// template <class T> T&& forward (typename remove_reference<T>::type&& t) noexcept;

// // 精简之后的样子
// std::forward<T>(t);
// 当T为左值引用类型时，t将被转换为T类型的左值
// 当T不是左值引用类型时，t将被转换为T类型的右值
// 下面通过一个例子演示一下关于 forward 的使用:

template<class T>
void printValue(T&t)
{
    cout<<"l-value"<<t<<endl;
}

template<class T>
void printValue(T&&t)
{
    cout<<"r-value"<<t<<endl;
}

template<class T>
void testForward(T&&v)
{
    printValue(v);
    printValue(move(v));
    printValue(forward<T>(v));
    cout<<endl;
}
void test2()
{
    testForward(520);    // l r r
    int num=1314;       
    testForward(num);    //l r l
    testForward(forward<int>(num));// l r r
    testForward(forward<int&>(num)); // l r l
    testForward(forward<int&&>(num));  //  l r r
}
/*
l-value: 520
r-value: 520
r-value: 520

l-value: 1314
r-value: 1314
l-value: 1314

l-value: 1314
r-value: 1314
r-value: 1314

l-value: 1314
r-value: 1314
l-value: 1314

l-value: 1314
r-value: 1314
r-value: 1314
testForward(520); 函数的形参为未定引用类型 T&&，实参为右值，初始化后被推导为一个右值引用
printValue(v); 已命名的右值 v，编译器会视为左值处理，实参为左值
printValue(move(v)); 已命名的右值编译器会视为左值处理，通过 move 又将其转换为右值，实参为右值
printValue(forward<T>(v));forward 的模板参数为右值引用，最终得到一个右值，实参为 ``右值`
testForward(num); 函数的形参为未定引用类型 T&&，实参为左值，初始化后被推导为一个左值引用
printValue(v); 实参为左值
printValue(move(v)); 通过 move 将左值转换为右值，实参为右值
printValue(forward<T>(v));forward 的模板参数为左值引用，最终得到一个左值引用，实参为左值
testForward(forward<int>(num));forward 的模板类型为 int，最终会得到一个右值，函数的形参为未定引用类型 T&& 被右值初始化后得到一个右值引用类型
printValue(v); 已命名的右值 v，编译器会视为左值处理，实参为左值
printValue(move(v)); 已命名的右值编译器会视为左值处理，通过 move 又将其转换为右值，实参为右值
printValue(forward<T>(v));forward 的模板参数为右值引用，最终得到一个右值，实参为右值
testForward(forward<int&>(num));forward 的模板类型为 int&，最终会得到一个左值，函数的形参为未定引用类型 T&& 被左值初始化后得到一个左值引用类型
printValue(v); 实参为左值
printValue(move(v)); 通过 move 将左值转换为右值，实参为右值
printValue(forward<T>(v));forward 的模板参数为左值引用，最终得到一个左值，实参为左值
testForward(forward<int&&>(num));forward 的模板类型为 int&&，最终会得到一个右值，函数的形参为未定引用类型 T&& 被右值初始化后得到一个右值引用类型
printValue(v); 已命名的右值 v，编译器会视为左值处理，实参为左值
printValue(move(v)); 已命名的右值编译器会视为左值处理，通过 move 又将其转换为右值，实参为右值
printValue(forward<T>(v));forward 的模板参数为右值引用，最终得到一个右值，实参为右值

*/
int main() {
    test();
    test2();
	return 0;
}