1. 右值引用
C++11
以前,右值被认为是无用的资源,所以在C++11
中引入了右值引用,就是为了重用右值。定义右值引用需要使用&&
。
右值引用一定不能被左值所初始化,只能用右值初始化。那么为什么呢?因为右值引用的目的是为了延长用来初始化对象的生命周期,对于左值,其生命周期与其作用域有关,你没有必要去延长。既然是延长,那么就出现了下面的情况:
int x = 20; // 左值
int&& rx = x * 2; // x*2的结果是一个右值,rx延长其生命周期
int y = rx + 2; // 因此你可以重用它:42
rx = 100; // 一旦你初始化一个右值引用变量,该变量就成为了一个左值,可以被赋值
复制代码
1.1. 右值引用作用
1.1.1. 延长生命周期
在C++11以前,我们常写如下例子:
class A
{
public:
A() : m_ptr(new int(0))
{
cout << "construct" << endl;
}
A(const A& rhs) : m_ptr(new int(*rhs.m_ptr)) // 拷贝构造函数
{
cout << "copy construct" << endl;
}
~A()
{
cout << "destruct" << endl;
delete m_ptr;
}
private:
int* m_ptr;
};
A Get(bool flag)
{
A a, b;
if (flag)
{
return a;
}
return b;
}
int main()
{
A a = Get(false);//调用拷贝构造函数
return 0;
}
执行结果:
construct
construct
copy construct
destruct
destruct
destruct
复制代码
问题:上述例子中Get
函数会返回临时变量,然后通过这临时变量拷贝构造一个新的对象a
,临时变量在拷贝构造完成之后就销毁了,如果堆内存很大,这个拷贝构造就比较消耗时间,带来性能的损耗,是否有方法避免临时对象的拷贝构造呢?即改成如下形式:
class A
{
public:
A() : m_ptr(new int(0))
{
cout << "construct" << endl;
}
A(const A& rhs) : m_ptr(new int(*rhs.m_ptr)) // 拷贝构造函数
{
cout << "copy construct" << endl;
}
A(A&& rhs) : m_ptr(rhs.m_ptr) //移动构造函数
{
rhs.m_ptr = nullptr;
cout << "move construct" << endl;
}
~A()
{
cout << "destruct" << endl;
delete m_ptr;
}
private:
int* m_ptr;
};
A Get(bool flag)
{
A a, b;
if (flag)
{
return a;
}
return b;
}
int main()
{
A a = Get(false);//调用拷贝构造函数
return 0;
}
执行结果:
construct
construct
move construct
destruct
destruct
destruct
复制代码
改进之后,不再调用拷贝构造函数,而是调用了移动构造函数(move construct)
。从移动构造函数的实现可以看到,它的参数是一个右值引用类型的参数T&&
,这里没有深拷贝,只有浅拷贝,这样就避免了对临时对象的深拷贝,和资源的重复申请和释放,提高了性能;延长了临时对象的生命周期,即上述例子中把返回值临时对象的生命周期交由给main
函数中的a
对象。
1.1.2. 转移不可拷贝的资源
如果资源是 不可拷贝 (non-copyable)
的,那么装载资源的对象也应该是不可拷贝的。
如果资源对象不可拷贝,一般需要定义 移动构造/移动赋值 函数,并禁用 拷贝构造/拷贝赋值 函数。例如,智能指针 std::unique_ptr
只能移动 (move only)
:
template<typename T>
class unique_ptr {
public:
unique_ptr(const unique_ptr& rhs) = delete;
unique_ptr(unique_ptr&& rhs) noexcept; // move only
private:
T* data_ = nullptr;
};
unique_ptr::unique_ptr(unique_ptr&& rhs) noexcept {
auto &lhs = *this;
lhs.data_ = rhs.data_;
rhs.data_ = nullptr;
}
复制代码
1.2. 右值引用几点说明
- 右值引用就是对一个右值进行引用的类型,因为右值不具名,因此只能通过引用的方式找到它;
- 通过右值引用的声明,该右值又“重获新生(生命周期延长,原本是生命周期是要结束)”,其生命周期与右值引用类型变量的生命周期一样;
- 无论声明为右值引用还是左值引用都必须立即初始化;
1.3. 右值引用解决如下问题
1.3.1. 移动语义std::move
移动语义是通过右值引用来匹配临时值的,那么,普通的左值是否也能借助移动语义来优化性能呢?
C++11
为了解决上述问题,提供了std::move
方法来将左值转换为右值,从而方便应用移动语义,即无论你传给它的是左值还是右值,通过std::move
之后都变成了右值;move
实际上并不能移动任何东西,他唯一的功能是将一个左值强制转换为一个右值引用,使我们可以通过右值引用使用该值;
class string {
public:
string(const string& other); // Copy constructor, exists pre C++11
string(string&& other) { // Move constructor, new in C++11
length = other.length;
capacity = other.capacity;
data = other.data;
other.data = nullptr; // 将临时对象的指针设置为空,other.data = nullptr;。若不将other.data设置为空,other.data 将被释放两次,导致程序异常。
}
private:
size_t length;
size_t capacity;
const char* data;
};
int main(){
string a(get_string()); // move constructor
string b(a); // copy constructor
string c(std::move(b)); // move constructor
return 0;
}
复制代码
**注意:**若string
中没有移动构造函数string(string&& other)
,上述的string c(std::move(b))
仍然将调用拷贝构造函数进行构造,因为string(const string& other)
的参数是const reference
。
C++11
中,编译器将会在类中自动添加移动构造函数和移动赋值操作符,因此C++11
中,声明一个类,编译器会默认添加构造函数、拷贝构造函数、析构函数、移动构造函数和移动赋值操作,号称类中的"5驾马车",而不是C++11
之前的“3
驾马车”。
若用户自定义拷贝构造函数,编译器将不会自动添加移动构造函数和移动赋值操作。可以在这些函数之后添加 = delete
,显示的阻止编译器自动添加对应的函数。
通过std::move
将左值转移成右值后,即原来的变量放弃了内存的所有权,后续代码不能使用该变量来访问对象;如果使用,会出现 未定义行为。
std::string base_url = tag->GetBaseUrl();
if (!base_url.empty()) {
UpdateQueryUrl(std::move(base_url) + "&q=" + word_); //若执行了,后续base_url不能使用,若使用会出现未定义行为。
}
LOG(INFO) << base_url; // |base_url| may be moved-from
复制代码
而被移动的对象处于于合法但未指定状态:
- 基本要求)能正确析构(不会重复释放已经被移动了的资源,例如
std::unique_ptr::~unique_ptr()
检查指针是否需要delete
) - (一般要求)重新赋值后,和新的对象没有差别(
C++
标准库基于这个假设) - (更高要求)恢复为默认值(例如
std::unique_ptr
恢复为nullptr
)
auto p = std::make_unique<int>(1);
auto q = std::move(p);
assert(p == nullptr); // OK: reset to default
p.reset(new int{2}); // or p = std::make_unique<int>(2);
assert(*p == 2); // OK: reset to int*(2)
复制代码
由于基本类型不包含资源,其移动和拷贝相同:被移动后,保持为原有值。
int i = 1;
int j = std::move(i);
assert(i == j)
复制代码
1.3.2. 完美转发std::forward
完美转发实现了参数在传递过程中保持其值属性的功能,即若是左值,则传递之后仍然是左值,若是右值,则传递之后仍然是右值。
void func(int &arg) {
std::cout << "func lvalue" << std::endl;
}
void func(int &&arg) {
std::cout << "func rvalue" << std::endl;
}
template <typename T>
void wrapper(T &&args) { //无论args是什么引用类型,args都是左值
func(args);
}
int main() {
int a = 10;
wrapper(a); //传递左值
wrapper(20); //传递右值
return 0;
}
以上函数输出:
func lvalue
func lvalue
复制代码
上述例子并没有做到对应的调用,其对应原因是:在wrapper
函数中调用func
函数时,对应的引用类型不能保持不变,即引用属性不能进行传递。所以,C++11
提供了std::forward()
函数用于完美转发。即,在转发过程中,左值引用在被转发之后仍然保持左值属性,右值引用在被转发之后依然保持右值属性。修改之后的代码如下:
void func(int &arg) {
std::cout << "func lvalue" << std::endl;
}
void func(int &&arg) {
std::cout << "func rvalue" << std::endl;
}
template <typename T>
void wrapper(T &&args) {
func(std::forward<T>(args));
}
int main() {
int a = 10;
wrapper(a);
wrapper(20);
return 0;
}
结果输出如下:
func lvalue
func rvalue
复制代码
2. 拷贝省略
尽管C++
引入了移动语义,移动的过程 仍有优化的空间 —— 与其调用一次 没有意义的移动构造函数,不如让编译器 直接跳过这个过程 —— 于是就有了拷贝省略(copy elision)
。
然而,很多人会把移动语义和拷贝省略 混淆:
- 移动语义是 语言标准 提出的概念,通过编写遵守移动语义的 移动构造函数、右值限定成员函数,逻辑上 优化 对象内资源 的转移流程
- 拷贝省略是(
C++ 17
前)非标准的 编译器优化,跳过移动/拷贝构造函数,让编译器直接在 移动后的对象 内存上,构造 被移动的对象
std::unique_ptr<int> foo() {
auto ret = std::make_unique<int>(1);
//...
return std::move(ret); // -> return ret;
}
复制代码
没必要使用 std::move() 移动非引用返回值。C++ 会把 即将离开作用域的 非引用类型的 返回值当成 右值,对返回的对象进行移动构造(语言标准);如果编译器允许拷贝省略,还可以省略这一步的构造,直接把 ret 存放到返回值的内存里(编译器优化)。
3. std::move和std::forward的用处
3.1. case1——不移动右值引用参数
std::unique_ptr<int> bar(std::unique_ptr<int>&& val) {
//...
return val; // not compile
// -> return std::move/forward(val);
}
复制代码
上述代码的问题在于:没有对返回值使用 std::move()
(编译器提示 std::unique_ptr(const std::unique_ptr&) = delete
错误)。
因为不论 左值引用 还是 右值引用 的变量(或参数)在初始化后,都是左值。所以,返回右值引用变量时,需要使用 std::move()/std::forward()
显式的 移动转发 或 完美转发,将变量 “还原” 为右值(右值引用类型)。