文章目录
移动语义
移动语意对带有资源托管的对象，资源可以转移的且转移后能保证安全的，特别适合，还能降低析构复杂度，一些天生具有不可复制性对象也特别适合，比如unique_ptr。通俗理解就是一些带资源的对象需要拷贝时，想要有浅拷贝的效率，还想要深拷贝析构时安全的效果，正所谓鱼和熊掌不可兼得，那么被拷贝者资源权转给拷贝者，自己不再使用，来保证安全和高效。其它对象，移动语意可能就没有什么明显的优势
引入C++11的移动语意
举个生活的例子，小明今年3岁了，爸妈响应号召，又给他添加了一个弟弟，现在4个月了，需要换一个66码的衣服，这时可以选择新买一件，也可以选择穿小明小时候留下来的。重新买需要花钱，有一定经济成本，相当于我们刚才的深拷贝，穿小明的，相当于废物利用，重新焕发价值，不花钱也不产生家庭经济压力，就相当于我们的移动语意，一个对象的资源在销毁前，我们将其转移给其它对象再用起来，这样能减少资源带来的构造开销，程序获得更高的效能。
举个例子：
移动语义定义: 在现有的 C++ 机制中，我们可以定义拷贝构造函数和赋值函数。 要实现转移语义，需要定义转移构造函数，还可以定义转移赋值操作符。 对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。 如果转移构造函数和转移拷贝操作符没有定义，那么就遵循现有的机制，拷贝构造函数和赋值操作符会被调用。 普通的函数和操作符也可以利用右值引用操作符实现转移语义
class MyString
{
public:
MyString(const char *tmp = "abc")
{//普通构造函数
len = strlen(tmp); //长度
str = new char[len+1]; //堆区申请空间
strcpy(str, tmp); //拷贝内容
cout << "普通构造函数 str = " << str << endl;
}
MyString(const MyString &tmp)
{//拷贝构造函数
len = tmp.len;
str = new char[len + 1];
strcpy(str, tmp.str);
cout << "拷贝构造函数 tmp.str = " << tmp.str << endl;
}
//移动构造函数
//参数是非const的右值引用
MyString(MyString && t)
{
str = t.str; //拷贝地址，没有重新申请内存
len = t.len;
//原来指针置空
t.str = NULL;
cout << "移动构造函数" << endl;
}
MyString &operator= (const MyString &tmp)
{//赋值运算符重载函数
if(&tmp == this)
{
return *this;
}
//先释放原来的内存
len = 0;
delete []str;
//重新申请内容
len = tmp.len;
str = new char[len + 1];
strcpy(str, tmp.str);
cout << "赋值运算符重载函数 tmp.str = " << tmp.str << endl;
return *this;
}
//移动赋值函数
//参数为非const的右值引用
MyString &operator=(MyString &&tmp)
{
if(&tmp == this)
{
return *this;
}
//先释放原来的内存
len = 0;
delete []str;
//无需重新申请堆区空间
len = tmp.len;
str = tmp.str; //地址赋值
tmp.str = NULL;
cout << "移动赋值函数\n";
return *this;
}
~MyString()
{//析构函数
cout << "析构函数: ";
if(str != NULL)
{
cout << "已操作delete, str = " << str;
delete []str;
str = NULL;
len = 0;
}
cout << endl;
}
private:
char *str = NULL;
int len = 0;
};
MyString func() //返回普通对象，不是引用
{
MyString obj("mike");
return obj;
}
void mytest()
{
MyString &&tmp1 = func(); //右值引用接收
MyString tmp2("abc"); //实例化一个对象
tmp2 = func();
return;
}
int main()
{
mytest();
system("pause");
return 0;
}move
在 C++11 添加了右值引用，并且不能使用左值初始化右值引用，如果想要使用左值初始化一个右值引用需要借助 std::move () 函数，使用std::move方法可以将左值转换为右值。使用这个函数并不能移动任何东西，而是和移动构造函数一样都具有移动语义，将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存拷贝
从实现上讲，std::move 基本等同于一个类型转换：static_cast<T&&>(lvalue);，函数原型如下:
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));
}
使用方法如下：
class Test
{
public：
Test(){}
......
}
int main()
{
Test t;
Test && v1 = t; // error
Test && v2 = move(t); // ok t中资源转移给v2
return 0;
}在第 4 行中，使用左值初始化右值引用，因此语法是错误的
在第 5 行中，使用 move() 函数将左值转换为了右值，这样就可以初始化右值引用了
假设一个临时容器很大，并且需要将这个容器赋值给另一个容器，就可以执行如下操作：
list<string> ls;
ls.push_back("hello");
ls.push_back("world");
......
list<string> ls1 = ls; // 需要拷贝, 效率低
list<string> ls2 = move(ls);//资源移动
如果不使用 move，拷贝的代价很大，性能较低。使用 move 几乎没有任何代价，只是转换了资源的所有权。如果一个对象内部有较大的堆内存或者动态数组时，使用 move () 就可以非常方便的进行数据所有权的转移。另外，我们也可以给类编写相应的移动构造函数（T::T(T&& another)）和和具有移动语义的赋值函数（T& T::operator=(T&& rhs)），在构造对象和赋值的时候尽可能的进行资源的重复利用，因为它们都是接收一个右值引用参数。
forward
为了解决右值引用折叠的问题，右值引用类型是独立于值的，一个右值引用作为函数参数的形参时，在函数内部转发该参数给内部其他函数时，它就变成一个左值，并不是原来的类型了。如果需要按照参数原来的类型转发到另一个函数，可以使用 C++11 提供的 std::forward () 函数，该函数实现的功能称之为完美转发。
// 函数原型
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类型的右值
eg:
下面通过一个例子演示一下关于 forward 的使用:
#include <iostream>
using namespace std;
template<typename T>
void printValue(T& t)
{
cout << "l-value: " << t << endl;
}
template<typename T>
void printValue(T&& t)
{
cout << "r-value: " << t << endl;
}
template<typename T>//万能引用
void testForward(T && v)
{
printValue(v);
printValue(move(v));
printValue(forward<T>(v));
cout << endl;
}
int main()
{
testForward(520);
int num = 1314;
testForward(num);
testForward(forward<int>(num));
testForward(forward<int&>(num));
testForward(forward<int&&>(num));
return 0;
}
测试代码打印的结果如下:
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 的模板参数为右值引用，最终得到一个右值，实参为右值