前言
上一期介绍了C++11的基础新特性，这一期开始我们继续来介绍C++11的新特性！
目录
前言
一、右值引用和移动语义
1.1左值和左值引用
1.2右值和右值引用
1.3左值引用vs右值引用
1.4右值引用的使用场景和意义
左值引用的使用场景
左值引用的缺陷
1.5右值引用左值及一些更加深入的使用场景分析
• 理解右值引用本身是左值
二、完美转发
2.1万能引用
2.2完美转发
2.3完美转发的使用场景
一、右值引用和移动语义
传统的C++语法就有了用用的语法，而在C++11中新增了右值引用的新语法特性，所以我们从现在开始把之前学习的引用就叫做左值引用！无论左值引用还是右值引用都是给对象取别名！
1.1左值和左值引用
• 左值是一个数据的表达式(如变量名/解引用的指针)，我们可以对它进行取地址 + 赋值；
• 左值可以出现再赋值符号的左边，也可以出现在赋值符号的右边；
• const 修改的左值，不能给他赋值但是可以取地址；
• 左值引用就是给左值取别名！
// 下面的都是 左值
int a = 10;
int* pa = &a;
const int b = 3;
// 下面都是 左值引用
int& ra = a;
int*& rpa = pa;
const int& rb = b;
int& r = *pa;左值可以取地址 ：
1.2右值和右值引用
• 右值也是一个数据的表达式(如：字面常量/表达式的返回值/函数的返回值等)；
• 右值也可以出现再赋值符号的右边，但是不能出现在左边；
• 右值不能取地址；
• 右值引用就是给右值取别名！
• 注意：右值引用本身是左值
// 右值 中的字面常量
10;
'a';
"hello";
3.14;
// 右值 中的表达式的返回值
double x = 1.1, y = 2.2;
x + y;
// 右值 中的函数返回值
fmin(x, y);
// 右值引用
int&& rr1 = 10;
char&& rr2 = 'a';
std::string&& rr3 = "hello";
double&& rr4 = 3.14;
double&& rr5 = x + y;
double&& rr6 = fmin(x, y);右值不能取地址：
小tips：虽然右值不能取地址，但是给右值取了别名后，会导致右值被存储到特定的位置，且可以对该位置取地址！也就是说，不能对字面量 10 取地址，但是可以对他的右值引用取地址，也可以修改他的右值引用！如果不想他的右值引用被修改可以用const修饰！
10;
// cout << &10 << endl;// error
int&& rr = 10;
cout << &rr << endl;
rr += 1;
cout << rr << endl;
// 如果不想修改
const int&& r = 10;
// r += 1;// error
当然右值引用的主要作用当然不是这个，了解有这个特性即可！
右值引用本身是左值：
要理解这个点，只能等把右值的使用场景和优势，介绍清楚才可以理解！
1.3左值引用vs右值引用
左值引用总结：
1、左值引用可以引用左值，不能引用右值
2、const 左值引用可以引用左值，也可以引用右值
关于第二点我们呢以前就介绍过，比如果临时对象具有常性，可以用const 引用，引用它！
// 左值引用只能引用左值，不能引用右值
int a = 10;
int& ra = a;
// int& ra2 = 10;// error
// const 左值引用既可以引用左值，也可以引用右值
const int& ra3 = 10;
const int& ra3 = a;右值引用总结：
1、右值引用只能引用右值
2、右值引用可以引用 move 后的左值
// 右值引用只能引用右值
int&& r1 = 10;
int a = 10;
//int&& rr1 = a;// error
// 右值引用可以引用move后的左值
int&& r3 = std::move(a);上面的move函数的作用很简单，就是将左值转换为右值引用！
1.4右值引用的使用场景和意义
前面刚介绍了，左值引用不仅可以引用左值，const左值引用也可以引用右值，那为什么C++11还要提出右值引用呢？要理解这个问题就得先来搞清楚左值引用的短板了！
为了方便以后的演示这里先把以前实现的string 给拷贝过来：
namespace cp
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
// s1.swap(s2)
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
// 拷贝构造
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷贝构造" << endl;
string tmp(s._str);
swap(tmp);
}
// 赋值重载
string& operator=(const string& s)
{
cout << "string& operator=(string s) -- 赋值拷贝" << endl;
string tmp(s);
swap(tmp);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
//string operator+=(char ch)
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
private:
char* _str;
size_t _size;
size_t _capacity; // 不包含最后做标识的\0
};
cp::string to_string(int value)
{
bool flag = true;
if (value < 0)
{
flag = false;
value = 0 - value;
}
cp::string str;
while (value > 0)
{
int x = value % 10;
value /= 10;
str += ('0' + x);
}
if (flag == false)
{
str += '-';
}
std::reverse(str.begin(), str.end());
// return move(str);
return str;
}
}左值引用的使用场景
做参数和返回值可以提高效率
做参数体现在： 因为引用是别名嘛，在语法上不开空间！所以做参数的话就不需要拷贝了，对于内置类型不关紧要，但是如果参数是一个自定类型的对象，例如string等不是引用就要拷贝，但是如果是引用就不需要拷贝了！极大的提高了效率！
做返回值体现在： 例如上面的operator+=，如果不是引用返回，就得拷贝，然后在返回！由于执行完+=外面的对象并没有销毁所以可以用引用返回，减少了一次拷贝提高了效率！
小tips：左值引用做返回值的前提是，当出了作用域那个对象还在！
void func1(cp::string s)
{}
void func2(cp::string& s)
{}
int main()
{
cp::string s1("hello world");
func1(s1);
func2(s1); // 这里体现的就是 左值引用做参数的场景
// string operator+=(char ch) 传值返回存在深拷贝
// string& operator+=(char ch) 传左值引用没有拷贝提高了效率
return 0;
}左值引用的缺陷
当函数的返回值是一个局部的变量，除了函数作用域就不存在了，就不能使用左值引用返回， 只能传值返回。例如：上面的to_string，这里返回至少是做一次拷贝构造（深拷贝），有一些老的编译器可能走两次，例如VS2013！
第一个拷贝构造是to_string的str的构造，然后是临时对象的拷贝构造，最后一个构造是因为拷贝构造的内部走的是现代写法，即调用了构造！ 我的这个vs2019比较新，优化成了1次深拷贝。我当前的电脑没有vs2013，如果你有的话可自行验证！
为了解决上述的值返回造成深拷贝的问题，C++11引入了右值引用和移动语义！
在cp::string中增加移动构造，移动构造本质就是将参数右值的资源转移过来，占为己有，那么就不用做深拷贝了，所以它叫做移动构造，就是转移别人的资源来构造自己！
// 移动构造
string(string&& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
一开始的那个 构造是to_string内部的str的构造！
当然不仅有移动构造，还有移动赋值！
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
} 
其实这里引入了右值引用之后，在to_string的那里str被编译器给move成了右值引用！当然你也可以自己手动的move效果一样！
1.5右值引用左值及一些更加深入的使用场景分析
按照语法，右值引用只能引用右值，但是右值引用一定不能引用左值嘛？由于，有些场景下，可能站的需要右值取引用左值实现移动语义。当需要右值引用，引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()；位于<utility> 头文件中，该函数的名字具有迷惑性，他并不是搬移任何的东西，唯一的功能就是将一个左值强制转为右值引用，然后实现移动语义！
template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
// forward _Arg as movable
return ((typename remove_reference<_Ty>::type&&)_Arg);
}cp::string s1("hello world");
cp::string s2(s1);// 拷贝构造
cp::string s3(std::move(s1));// move之后就是走的移动构造
第一次构造是s1的，下来是s1拷贝给s2的拷贝构造，拷贝构造内部是现代写法所以有第三个构造，最后一个就是s3的移动构造！
当然C++11不仅引入了右值引用，而且将他也增加到了STL中，例如：
这里不在一一介绍了！
• 理解右值引用本身是左值
右值引用的本质是为了解决自定义类型的值返回的问题，而你想将局部变量/对象返回的资源做转移，就必须得接受他，也就是你得可以修改，不然无法写入地址，也就无法转移了！所以，他这里设计其实可能是为了语法自洽！
二、完美转发
2.1万能引用
模板中的&&是万能引用，不是右值引用；他既可以接受左值又可以接受右值！他会根据接受的参数确定时左值还是右值！
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
template<typename T>
void PerfectForward(T&& t)
{
Fun(t);
}这个例子中的T&&就是万能引用！此时我们可以，试一下，是不是可以既可以接受左值，又可以介绍右值：
PerfectForward(10);// 右值
int a;
PerfectForward(a);
PerfectForward(std::move(a)); // 右值
const int b = 8;
PerfectForward(b); // const 左值
PerfectForward(std::move(b)); // const 右值
哎？这怎么都是左值呢？？其实仔细一想，就能知道，如果接受的值本身是左值，那就正常！但是接受的值是右值，不应该是右值吗？？？是的！但是前面刚说了：“右值引用本身也是一个左值”！所以这里也就不奇怪了！如果想要是调用Fun时是右值，带用右值引用的Fun该咋办呢？其实也就是一直想保持原本的属性（左值/右值），这就是下面要介绍的完美转发了~！
2.2完美转发
std::forward 完美转发在传参的过程中，保留对象的原生属性！
所以上面的问题，可以用完美转发，完美的解决：
2.3完美转发的使用场景
template<class T>
struct ListNode
{
ListNode* _next = nullptr;
ListNode* _prev = nullptr;
T _data;
};
template<class T>
class List
{
typedef ListNode<T> Node;
public:
List()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(T&& x)
{
//Insert(_head, x);
Insert(_head, std::forward<T>(x));
}
void PushFront(T&& x)
{
//Insert(_head->_next, x);
Insert(_head->_next, std::forward<T>(x));
}
void Insert(Node* pos, T&& x)
{
Node* prev = pos->_prev;
Node* newnode = new Node;
newnode->_data = std::forward<T>(x); // 关键位置
// prev newnode pos
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = pos;
pos->_prev = newnode;
}
void Insert(Node* pos, const T& x)
{
Node* prev = pos->_prev;
Node* newnode = new Node;
newnode->_data = x; // 关键位置
// prev newnode pos
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = pos;
pos->_prev = newnode;
}
private:
Node* _head;
};想list这里使用右值插入的时候，你所用的每一层都需要修改！但是如果使用move的话，每一层都需要修改，维护成本高且麻烦，易出错！所以，完美转发就是这种问题的完美解决者~！
OK，好兄弟本期分享就到这里！我是cp我们下期再见！
![[yotroy.cool] MGT 388 - Finance for Engineers - notes 笔记](https://img-home.csdnimg.cn/images/20230724024159.png?origin_url=https%3A%2F%2Ffile.yotroy.cool%2Ffinance_lecture_25.png%3Fx-oss-process%3Dstyle%2F1&pos_id=img-wJFzOVqW-1726560343812)
