1.移动语义
移动构造和移动赋值均属于移动语义范畴。
移动语义的实现依赖于右值概念,右值引用。
1.1.一个移动构造的实例
#include <iostream>
using namespace std;
class HasPtrMem{
public:
HasPtrMem():d(new int(3)){
cout << "Construct: " << ++n_cstr << endl;
}
HasPtrMem(const HasPtrMem& h):d(new int(*h.d)){
cout << "Copy construct: " << ++n_cptr << endl;
}
HasPtrMem(HasPtrMem&& h):d(h.d){
h.d = nullptr;
cout << "Move construct: " << ++n_mvtr << endl;
}
~HasPtrMem(){
delete d;
cout << "Destruct: " << ++n_dstr << endl;
}
int *d;
static int n_cstr;
static int n_dstr;
static int n_cptr;
static int n_mvtr;
};
int HasPtrMem::n_cstr = 0;
int HasPtrMem::n_dstr = 0;
int HasPtrMem::n_cptr = 0;
int HasPtrMem::n_mvtr = 0;
HasPtrMem GetTemp(){
HasPtrMem h;// 1.局部对象构造
cout << "Resource from " << __func__ << ": " << hex << h.d << endl;
return h;
}// 3.局部对象析构
int main()
{
// 2.匿名对象拷贝构造--实参为即将析构的局部变量时匹配到右值版本
// 4.对象a拷贝构造,实参为匿名临时对象时匹配到右值版本
HasPtrMem a = GetTemp();
// 3.匿名对象析构
cout << "Resource from " << __func__ << ": " << hex << a.d << endl;
// 4.对象a析构
}
对其执行:g++ -std=c++11 44.cpp -fno-elide-constructors -o 44
,再执行./.44
。
上述以函数内临时变量为实参拷贝构造匿名临时变量,以匿名临时变量为实参拷贝构造变量a
时均触发了移动拷贝构造。
移动拷贝构造的形参是一个右值引用类型。
我们需要先理解:
(1). 左值,右值。
(2). 左值引用,常量左值引用,右值引用作为形参时可接收的实参。及各类实参和形参匹配的优先级。
才能较好的把握移动拷贝,移动赋值的使用。
从理解上来说,针对需要管理资源的类型,我们将拷贝和赋值区分为浅拷贝,浅赋值和深拷贝,深赋值。
浅指的是我们通过窃取目标对象资源来完成资源转移。深指的是我们自己产生资源,然后使其和目标对象内容一致。
这种场景下,类型通过提供移动拷贝,移动赋值来实现浅拷贝,浅赋值。通过提供拷贝构造,赋值来实现深拷贝,深赋值。
1.2.左值,右值
c++
程序中,所有的值必属于左值,将亡值,纯右值三者之一。
将亡值,纯右值均属于右值范畴。
(1). 纯右值
和C
中右值概念一致。
a. 非引用返回的函数返回的匿名临时变量值。
b. 一些运算表达式,诸如 1 + 3
产生的匿名临时变量值。
c. 不跟对象关联的字面量值,比如:2、'c'、true
。
d. 类型转换函数返回的匿名临时变量值。
e. lambda
表达式返回的匿名临时变量值。
(2). 将亡值
C++
特有。
a. 返回右值引用T&&
的函数返回值–匿名右值引用类型。
b. std::move
的返回值–匿名右值引用类型。
c. 转换为T&&
的类型转换函数的返回值–匿名右值引用类型。
(3). 左值
排除(1),(2)
后的可标识函数,对象值都属于左值。
1.3.非常量左值引用,常量左值引用,非常量右值引用,常量右值引用
常量和非常量,左值和右值是可以同时用于修饰对象的两类性质。
右值存在的价值一个是用于实现移动语义,一个是用于实现完美转发。
一般,常量右值引用没有存在的意义,因为:
(1). 右值用于移动语义时,我们窃取其资源后,需要对其修改以便阻止资源多次释放,野指针等问题。
(2). 如果需要引用右值且让右值不可通过引用更改,直接使用常量左值来引用即可。
使用右值作为实参来初始化右值引用,常量左值引用后,右值的生命期会被延长。
通过右值引用可以对引用对象进行修改,通过常量左值引用无法对引用对象进行修改。
#include <iostream>
class A
{
public:
A()
{
printf("A()_%x\n", this);
}
A(const A& a)
{
printf("A(const A&_%x)\n", this);
}
~A()
{
printf("~A()_%x\n", this);
}
public:
int i = 0;
};
A fun()
{
A a;
return a;
}
int main()
{
// 这里的变量除了a1,还有一个隐藏起来的匿名临时变量。
// 汇编执行时:
// 是匿名临时变量先接受了函数的返回值
// 再通过匿名临时变量完成了a1的初始化
// 这里函数内部临时变量a,变量a1均是左值
// 匿名临时变量是右值
A a1 = fun();
printf("tag1\n");
A&& a2 = fun();
printf("tag2\n");
a2.i = 1;
const A& a3 = fun();
printf("tag3\n");
return 0;
}
上述实例反映了两点:
(1). 通过采用右值引用或常量左值引用接受函数fun
的非引用类型返回值。使得返回值对应的匿名临时右值对象的生命期延长了。
(2). 通过右值引用可以修改所引用变量,通过常量左值引用则不可。
以下表格整理了引用类型及每种类型可以接受的初始化实参类型。
引用类型 | 可以引用的值类型 | 注记 |
---|---|---|
非常量左值引用 | 非常量左值 | |
常量左值引用 | 非常量左值,常量左值,非常量右值,常量右值 | 全能类型,用于深拷贝 |
非常量右值引用 | 非常量右值 | 移动语义,完美转发 |
常量右值引用 | 非常量右值,常量右值 |
1.4.std::move
#include <iostream>
class A
{
public:
A():m_c('a'){
printf("A()_%x\n", this);
}
A(A& a):m_c(a.m_c){
printf("A(&)_%x\n", this);
fun(a);
}
A(const A& a):m_c(a.m_c){
printf("A(const&)_%x\n", this);
fun(a);
}
A(A&& a):m_c(a.m_c){
printf("A(&&)_%x\n", this);
fun(a);
}
A(const A&& a):m_c(a.m_c)
{
printf("const A(&&)_%x\n", this);
fun(a);
}
A& operator=(A& a)
{
printf("=(A&)_%x\n", this);
m_c = a.m_c;
fun(a);
return *this;
}
A& operator=(const A& a)
{
printf("=(const A&)_%x\n", this);
m_c = a.m_c;
fun(a);
return *this;
}
A& operator=(A&& a)
{
printf("=(A&&)_%x\n", this);
m_c = a.m_c;
fun(a);
return *this;
}
A& operator=(const A&& a)
{
printf("=(const A&&)_%x\n", this);
m_c = a.m_c;
fun(a);
return *this;
}
void fun(A&& a)
{
printf("fun(A&&)_%x\n", this);
}
void fun(const A&& a)
{
printf("fun(const A&&)_%x\n", this);
}
void fun(A& a)
{
printf("fun(A&)_%x\n", this);
}
void fun(const A& a)
{
printf("fun(constA&)_%x\n", this);
}
~A()
{
printf("~A()_%x\n", this);
}
private:
char m_c;
};
void funn(A a)
{
}
int main()
{
A a;
const A a2;
printf("tag\n");
// std::move针对非常量左值,返回非常量右值引用。
// 非常量右值引用虽然是一个非常量右值的别名,但由于有了名字。所以,右值引用被当成一个左值。
// 故,通过非常量右值引用调用fun时,匹配到非常量左值引用版本。
A a3 = std::move(a);
printf("tag1\n");
// std::move针对常量左值,返回常量右值引用。
// 常量右值引用虽然是一个常量右值的别名,但由于有了名字。所以,右值引用被当成一个左值。
// 故,通过常量右值引用调用fun时,匹配到常量左值引用版本。
A a4 = std::move(a2);
printf("tag2\n");
// std::move针对非常量右值,返回非常量右值引用。
// 非常量右值引用虽然是一个非常量右值的别名,但由于有了名字。所以,右值引用被当成一个左值。
// 故,通过非常量右值引用调用fun时,匹配到非常量左值引用版本。
A a5 = std::move(A());
printf("tag3\n");
A& aa1 = a;
// std::move针对非常量左值引用,返回非常量右值引用。
A aaa1 = std::move(aa1);
printf("tag4\n");
const A& aa2 = a2;
// std::move针对常量左值引用,返回常量右值引用。
A aaa2 = std::move(aa2);
printf("tag5\n");
A&& aa3 = A();
// std::move针对非常量右值引用,返回非常量右值引用。
A aaa3 = std::move(aa3);
printf("tag6\n");
const A&& aa4 = A();
// std::move针对常量右值引用,返回常量右值引用。
A aaa4 = std::move(aa4);
printf("tag7\n");
A b;
funn(b);
printf("tag5\n");
return 0;
}
针对std::move
简单的总结是:
(1). 针对左值实参,左值引用实参会返回此实参的右值引用类型。
(2). 针对右值实参,右值引用实参会返回此实参的右值引用类型。
(3). 保持实参的常量属性不变。
注意点:
(1). 右值引用虽然是一个右值的引用,但由于引用本身是有名字的,所以,右值引用是一个左值类型。
(2). std::move
返回实参的右值引用,但这里相当于一个得到了匿名右值引用。所以将此返回值传参调用函数时,右值引用会被当成右值类型。而非(1)
中的左值类型。
关于std::move
保持实参的常量属性不变的辅助实例
#include <iostream>
void fun(int* && a)
{
printf("int* &&\n");
}
void fun(const int* && a)
{
printf("const int* &&\n");
}
void fun(int* const && a)
{
printf("int* const &&\n");
}
void fun(const int* const && a)
{
printf("const int* const &&\n");
}
int main()
{
int a1 = 10;
const int a11 = 10;
int *a = &a1;
const int* a2 = &a11;
int * const a3 = &a1;
const int* const a4 = &a11;
fun(std::move(a));
fun(std::move(a2));
fun(std::move(a3));
fun(std::move(a4));
return 0;
}
1.5.编译器的返回值优化
上述各个观察函数返回值的实例我们编译时,加了-fno-elide-constructors
选项来关闭编译器针对返回值的优化。当开启此优化时:
#include <iostream>
class A
{
public:
A(){
printf("A()_%x\n", this);
}
A(A&a){
printf("A(&)_%x\n", this);
}
A(const A&){
printf("A(const A&)_%x\n", this);
}
A(A&&){
printf("A(&&)_%x\n", this);
}
A(const A&&){
printf("A(const&&)_%x\n", this);
}
~A(){
printf("~A()_%x\n", this);
}
};
A fun()
{
A a;
return a;
}
int main()
{
A b= fun();
return 0;
}
b
直接霸占了fun
内部的变量a
。
此优化并不是对任何情况均有效。还有一些情形即使存在此优化,也不能达到最好效果。
而移动语义总是可以在显式控制下采用最有效的方法实现目标。
2.完美转发
完美转发指的是在函数模板中,完全依照模板参数的类型,将参数传递给函数模板中调用的另外一个函数。
2.1.引用折叠
为了支持完美转发,c++
既需要引入右值,右值引用。也需要引入引用折叠。
引用折叠进一步分为左值引用折叠,右值引用折叠。
// TR的类型定义为:T&,声明v的类型为TR& -> v的实际类型为:T&,又因为T为const int所以,v的实际类型为const int&,所以TR& v = 1;对应const int& v = 1;
#include <iostream>
typedef const int T;
typedef T& TR;
int main()
{
TR& v = 1;
}
TR的类型定义 | 声明v的类型 | v的实际类型 |
---|---|---|
T& | TR | T& |
T& | TR& | T& |
T& | TR&& | T& |
T&& | TR | T&& |
T&& | TR& | T& |
T&& | TR&& | T&& |
将上述引用折叠结合模板类型推断可以实现完美转发。
2.2.模板类型推断
当模板的形参中对模板类型采用T&&
的形式时,推断T
的类型时:
当转发函数的实参是类型X
的一个左值或左值引用,则模板参数T
被推导为X&
类型。
当转发函数的实参是类型X
的一个右值或右值引用,则模板参数T
被推导为X&&
类型。
此时需结合引用折叠规则来最终确定参数的实际类型。
一个实例
template<typename T>
void IamForwording(T&& t){
IrunCodeActually(static_cast<T&&>(t));
}
对于上述形式的转发函数,如果我们调用转发函数时传入了一个X
类型的左值或左值引用。则:
(1). 模板参数T被推断为X&
类型。
(2). 引用折叠完成后的实际的转发函数是
void IamForwording(X& t){
IrunCodeActually(<X&>(t));
}
这样通过左值或左值引用调用转发函数,最终调用实际函数的左值引用版本。
如果我们调用转发函数时传入了一个X
类型的右值或右值引用。则:
(1).模板参数T
被推断为X&&
类型。
(2).引用折叠完成后的实际的转发函数是
void IamForwording(X&& t){
IrunCodeActually(<X&&>t);
}
这样通过右值或右值引用调用转发函数,最终调用实际函数的右值引用版本。
上述<X&&>t
并不多余,因为若直接采用t
的形式调用实际函数,由于右值引用类型自身是左值所以将匹配到左值引用版本。
2.3.完美转发实例
#include <iostream>
using namespace std;
void RunCode(int&& m){ cout << "int&&" << endl; }
void RunCode(int& m){ cout << "int&" << endl; }
void RunCode(const int&& m) { cout << "const int&&" << endl; }
void RunCode(const int& m) { cout << "const int&" << endl; }
template<typename T>
void PerfectForward(T&& t){
RunCode(forward<T>(t));
}
int main(){
int a;
int b;
const int c = 1;
const int d = 0;
PerfectForward(a);
PerfectForward(move(b));
PerfectForward(c);
PerfectForward(move(d));
}
将上述转发函数改为如下形式,一样可以达到效果:
template<typename T>
void PerfectForward(T&& t){
RunCode(static_cast<T&&>(t));
}
若上述模板形参变成如下:
template<typename T>
void PerfectForward(T& t){
RunCode(static_cast<T&&>(t));
}
int main(){
int a;
int b;
const int c = 1;
const int d = 0;
PerfectForward(a);
PerfectForward(move(b));
PerfectForward(c);
PerfectForward(move(d));
}
则执行PerfectForward(move(b));
会报错,因为此时无法完成将一个右值引用匹配到【T
推断为int&&,T&t
的实际类型为int&
】int&
的转换。
而PerfectForward(move(d));
可以执行,此时是一个常量右值引用匹配到【T
推断为const int&&,T&t
的实际类型为const int&
】const int&
的转换,然后内部执行RunCode
会转变为一个const int&&
类型参与RunCode
的匹配过程。
这里static_cast<T&&>
折叠后变为static_cast<const int&&>
,这里的右值引用之所以不会当成作值类似std::move
返回的右值引用,是因为这里得到的右值引用是一个匿名的右值引用。所以,参与函数传参时,不会被当成左值。
为了完整,我们在main
中再补充一组测试
printf("tag\n");
int& aa = a;
const int& caa = c;
int&& aaa = move(a);
const int&& caaa = move(d);
PerfectForward(aa);
PerfectForward(caa);
PerfectForward(aaa);
PerfectForward(caaa);
上述补充内容对应的输出为:
因为这里的aaa,caaa
是有名字的右值引用,所以参与函数传参时,被当作左值对待了。