完美转发
1. 在函数模板中，可以将
自己的参数“完美”地转发
给其它函数。所谓完美，即
不仅能准确地转发参数的值，还能保证被转发参数的左、右值属性不变。
2. C++11标准引入了右值引用和移动语义，所以，能否实现完美转发，决定了该参数在传递过程使用的是拷贝语义(调用拷贝构造函数)还是移动语义 (调用移动构造函数)。
1. 如果模板中 (包括类模板和函数模板)函数的参数书写成为T&& 参数名 那么，函数既可以接受左值引用，又可以接受右值引用。
2. 提供了模板函数std::forward<T>(参数)，用于转发参数如果参数是一个右值，转发之后仍是右值引用;如果 参数是一个左值，转发之后仍是左值引用
move
在我的另一篇文章《
C++之右值引用、移动构造函数
》提到，
左值不能初始化右值引用。
那么我们能不能用左值初始化一个右值引用呢？？这里C++给我们了一个函数move();
move()函数
将左值转换为右值，实现对象资源的转移。
下面看个例子
void test2()
{
vector<int> v;
for (int i = 0; i < 10; i++)
v.push_back(i);
vector<int>vv = v; //拷贝
cout << "v =";
for (auto x : v)
cout << x << " ";
cout << "， v.addr=" << &v << endl;
cout << "vv =";
for (auto x : vv)
cout << x << " ";
cout << "， vv.addr=" << &vv << endl;
cout << "after move v to vvv" << endl;
vector<int>vvv = move(v);
cout << "vvv=";
for (auto x : vvv)
cout << x << " ";
cout << "，vvv.addr=" << &vvv << endl;
cout << "v =";
for (auto x : v)
cout << x << " ";
cout << "， v.addr=" << &v << endl;
}
forward
右值引用类型是独立于值的，一个
右值引用作为函数参数的形参时，在函数内部转发该参数给内部其他函数时，它就变成一个左值（因为没有实名的右值被编译器视为左值）
，并不是原来的类型了。
如果需要按照参数原来的类型转发到另一个函数
，可以使用 C++11 提供的 std::forward () 函数，该函数实现的功能称之为
完美转发。
#include<iostream>
using namespace std;
template<typename T>
void PrintT(T& t)
{
cout << "lvalue" << endl;
}
template<typename T>
void PrintT(T&& t)
{
cout << "rvalue" << endl;
}
template<typename T>
void TestForward(T&& v)
{
PrintT(v);
PrintT(move(v));
PrintT(forward<T>(v));
cout << endl;
}
int main()
{
TestForward(1);
int x = 1;
TestForward(x);
TestForward(forward<int>(x));
TestForward(forward<int&>(x));
TestForward(forward<int&&>(x));
return 0;
}分析一下
TestForward(1);实参为右值,T&&->右值引用
1. PrintT(v);已经实名的右值编译器当成左值处理,实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数为右值引用,最终得到一个右值,实参->右值
TestForward(x);实参为左值,T&&->左值引用
1. PrintT(v);实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数为左值引用,最终得到一个左值,实参->左值
TestForward(forward<int>(x));模板参数类型为int->右值,最终得到右值,T&&->右值引用
1. PrintT(v);已经实名的右值编译器当成左值处理,实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数为右值引用,最终得到一个右值,实参->右值
TestForward(forward<int&>(x));模板参数类型为左值引用,最终得到一个左值,T&&->左值引用
1. PrintT(v);实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数类型为左值引用,最终得到一个左值,实参->左值
TestForward(forward<int&&>(x));模板参数类型为右值引用,最终得到一个右值,T&&->右值引用
1. PrintT(v);已经实名的右值编译器当成左值处理,实参->左值
2. PrintT(move(v));move将左值转换为右值,实参->右值
3. PrintT(forward<T>(v));模板参数类型为右值引用,最终得到一个右值,T&&->右值引用
移动语义
如果一个对象中有堆区资源，需要编写拷贝构造函数和赋值函数，实现深拷贝。
深拷贝把对象中的堆区资源复制了一份，如果源对象(被拷贝的对象)是临时对象，拷贝完就没什么用了，这样会造成没有意义的资源申请和释放操作。如果能够
直接使用源对象拥有的资源
，可以
节省资源申请和释放的时间
。C++11 新增加的移动语义就能够做到这一点。
下面给出示例:
我们当时提到的深浅拷贝，深拷贝解决了浅拷贝造成的内存泄露问题，但是反复的构造和释放对象拉低了程序的效率。所以我们在想是否能直接使用原对象的资源，这样可以大大提高效率
#include<iostream>
using namespace std;
class AA
{
public:
int* m_data = nullptr;
AA() = default;
void alloc()
{
m_data = new int;
memset(m_data, 0, sizeof(int)); //初始化已分配的内存
}
AA(const AA& a) //拷贝构造函数
{
cout << "调用了拷贝构造函数" << endl;
if (m_data == nullptr) //如果没有分配内存，就分配
alloc();
memcpy(m_data, a.m_data, sizeof(int));
}
AA(AA&& a) //移动构造函数
{
cout << "调用了移动构造函数" << endl;
if (m_data != nullptr) //如果分配内存，释放掉
delete m_data;
m_data = a.m_data;
a.m_data = nullptr;
}
AA& operator=(const AA& a)
{
cout << "调用了赋值函数" << endl;
if (this == &a) //避免自我复制
return *this;
if (m_data == nullptr) //如果没有分配内存，就分配
alloc();
memcpy(m_data, a.m_data, sizeof(int));
return *this;
}
AA& operator=(AA&& a)
{
cout << "调用了移动赋值函数" << endl;
if (this == &a) //避免自我复制
return *this;
if (m_data != nullptr) //如果分配内存，释放掉
delete m_data;
m_data = a.m_data;
a.m_data = nullptr;
return *this;
}
~AA()
{
if (m_data != nullptr)
delete m_data;
m_data = nullptr;
}
};测试案例1
void test1()
{
cout << "test1-begin" << endl;
AA a1;
a1.alloc();
*a1.m_data = 3;
cout << "a1.m_data=" << *a1.m_data << endl;
AA a2(a1);
cout << "a2.m_data=" << *a2.m_data << endl;
AA a3;
a3 = a1;
cout << "a3.m_data=" << *a3.m_data << endl;
cout << "test1-end" << endl << endl;
}这是一组普通的测试案例，返回结果
注意：
-
对于一个左值，会调用拷贝构造函数，但是有些左值是局部变量，生命周期也很短，能不能也移动而不是拷贝呢?C++11为了解决这个问题，提供了std:move0方法来将左值转义为右值，从而方便使用移动语义。它其实就是告诉编译器，
虽然我是一个左值，但不要对我用拷贝构造函数，用移动构造函数吧。左值对象被转移资源后，不会立刻析构
，只有在离开自己的作用域的时候才会析构，如果继续使用左值中的资源，可能会发生意想不到的错误。
-
如果没有提供移动构造/赋值函数，只提供了拷贝构造/赋值函数，编译器找不到移动构造/赋值函数就去寻找拷贝构造/赋值函数。
-
C++11中的所有容器都实现了移动语义，避免对含有资源的对象发生无谓的拷贝
。
-
移动语义对于拥有资源（如内存，文件句柄）的对象，如果是基本类型，使用移动语义没有意义。
测试案例2
void test2()
{
cout << "test2-begin" << endl;
AA a1;
a1.alloc();
*a1.m_data = 3;
AA a6(std::move(a1));
cout << "a6.m_data=" << *a6.m_data << endl;
AA a7;
a7 = std::move(a1);
cout << "a7.m_data=" << *a7.m_data << endl;
cout << "test2-end" << endl << endl;
}返回结果
test2-begin
调用了移动构造函数
a6.m_data=3
调用了移动赋值函数
//程序到这里崩溃了为什么呢？
这里就是因为a1被转移资源后，下面再次对a1进行转移资源导致报错。
测试案例3
void test3()
{
cout << "test3-begin" << endl;
auto f = [] {AA aa; aa.alloc(); *aa.m_data = 8; return aa; };
AA a4 = f();
cout << "a4.m_data=" << *a4.m_data << endl;
AA a5;
a5 = f();
cout << "a5.m_data=" << *a5.m_data << endl;
cout << "test3-end" << endl << endl;
}返回结果
test3-begin
调用了移动构造函数
a4.m_data=8
调用了移动构造函数
调用了移动赋值函数
a5.m_data=8
test3-end