1. 概述
本文以一个例子引出移动语义、智能指针等C++基础概念，根据过程中遇到的问题，我们可以对为什么要有移动语义和智能指针有初步的理解。
这是一个关于移动语义和智能指针的连续剧，初步规划了五篇文章，它们分别是《Move语义和Smart Pointers先导（以一个例子说明）》、《左值、右值、左值引用和右值引用浅析》、《Move constructors 和 Move assignment constructors简介》、《Move语义和完美Forwarding介绍》和《C++内存管理——Smart Pointers》，建议一起食用，我也尽量一起完工。
2. 抛出一个问题
struct Resource
{
...
};
void func()
{
Resource* res = new Resource();
...
delete res;
}
如上面的代码，对于我们最常用的new/delete（在堆上动态地分配和释放内存），我们经常会忘记delete，即使记住了delete，也很容易由于别的原因导致出问题。
如下面的代码，当输入值为0时，由于函数提前return导致资源未释放，从而出现了不可忍受的内存泄露。
struct Resource
{
...
};
void func()
{
Resource* res = new Resource();
...
int num;
std::cin >> num;
if(0 == num)
{
return ;
}
std::cout << "Hello" << std::endl;
delete res;
}
3. 问题解决——智能指针类
我们应该都听说过RAII(Resource Acquisition Is Initialization)机制，它讲的是一个对象在构造时获取其对应的资源，在对象生命期内始终控制对其资源的有效访问，最后在对象析构时能够正确地释放构造时获取的资源。它是C++语言的一种管理资源、避免泄漏的常用手法，我们此处也使用一下。
此处我们实现一个指针类，当此指针类对象超过其生命周期时，它能正确地释放资源，如下：
#include <iostream>
template<typename T>
struct AutoPtr1
{
AutoPtr1(T* ptr = nullptr)
: ptr(ptr)
{
}
~AutoPtr1()
{
if(this->ptr != nullptr)
{
delete this->ptr;
this->ptr = nullptr;
}
}
T& operator*() const
{
return *this->ptr;
}
T* operator->() const
{
return this->ptr;
}
private:
T* ptr;
};
struct Resource
{
Resource()
{
std::cout << "Resource acquired" << std::endl;
}
~Resource()
{
std::cout << "Resource destroy" << std::endl;
}
};
int main()
{
AutoPtr1<Resource> res{new Resource()}; // allocate here, like smart point
return 0;
} // destroy the allocated resource here
此程序的输出如下：
Resource acquired
Resource destroy
此程序运行如下：
- 首先动态创建一个Resource对象，采用AutoPtr1<Resource>的指针res指向它（即res拥有此Resource对象的所有权）；
- res是一个局部变量，当超过它的生命周期后会调用AutoPtr1的析构函数，即被销毁。
只要AutoPtr1<Resource>类型的指针被定义为局部变量，不论函数如何终止，资源都会被释放掉（只要超过其生命周期，就会调用对应的析构函数）。
上面的AutoPtr1类就叫做智能指针，它可以管理动态分配的内存，并且当智能指针类超出其生命周期后能够正确地释放。
对于我们提前return的func()，我们可以采用智能指针解决，如下:
#include <iostream>
template<typename T>
struct AutoPtr1
{
AutoPtr1(T* ptr = nullptr)
: ptr(ptr)
{
}
~AutoPtr1()
{
if(this->ptr != nullptr)
{
delete this->ptr;
this->ptr = nullptr;
}
}
T& operator*() const
{
return *this->ptr;
}
T* operator->() const
{
return this->ptr;
}
private:
T* ptr;
};
struct Resource
{
Resource()
{
std::cout << "Resource acquired" << std::endl;
}
~Resource()
{
std::cout << "Resource destroy" << std::endl;
}
};
void func()
{
AutoPtr1<Resource> res{new Resource()};
...
int num;
std::cin >> num;
if(0 == num)
{
return ;
}
std::cout << "Hello" << std::endl;
}
int main()
{
func();
return 0;
}
当输入值为非0时，程序的输出如下：
Resource acquired
Hello
Resource destroyed
当输入值为0时，程序的输出如下：
Resource acquired
Resource destroyed
可以看到，不论程序正常/提前退出，Auto_ptr1的析构函数都会释放资源。
4. 继续抛出问题
下面的程序会出现什么问题？
#include <iostream>
template<typename T>
struct AutoPtr1
{
AutoPtr1(T* ptr = nullptr)
: ptr(ptr)
{
}
~AutoPtr1()
{
if(this->ptr != nullptr)
{
delete this->ptr;
this->ptr = nullptr;
}
}
T& operator*() const
{
return *this->ptr;
}
T* operator->() const
{
return this->ptr;
}
private:
T* ptr;
};
struct Resource
{
Resource()
{
std::cout << "Resource acquired" << std::endl;
}
~Resource()
{
std::cout << "Resource destroy" << std::endl;
}
};
int main()
{
AutoPtr1<Resource> res1{new Resource()};
AutoPtr1<Resource> res2(res1);
return 0;
}
程序的输出如下：
Resource acquired
Resource destroyed
Resource destroyed
为什么资源被释放两次？因为我们没有显式地提供拷贝构造或赋值构造函数，当执行AutoPtr1<Resource> res2(res1)时系统会生成默认的一套“浅拷贝”的拷贝构造或赋值构造函数。所以当执行完AutoPtr1<Resource> res2(res1)后，res1和res2都指向了相同的内容，最后res2释放一次内存，res1也释放了相同的内存，导致程序崩溃。
5. 问题解决——Move语义
对于上述的问题，我们有三套解决方案，如下：
- 显式地将拷贝构造函数和拷贝赋值函数定义为delete，但是这会使好多功能不可用；
- 实现自己“深拷贝”版本的拷贝构造函数和拷贝赋值函数，但是深拷贝的操作是有代价的；
- 相对于“Copy语义”，可以采用“Move语义”，它仅仅转移了对象的所有权，并没有拷贝。
采用方案3的实现如下：
#include <iostream>
template<typename T>
struct AutoPtr2
{
AutoPtr2(T* ptr = nullptr)
: ptr(ptr)
{
}
~AutoPtr2()
{
if(this->ptr != nullptr)
{
delete this->ptr;
this->ptr = nullptr;
}
}
AutoPtr2(AutoPtr2& ptr2) // not const
{
this->ptr = ptr2.ptr;
ptr2.ptr = nullptr;
}
AutoPtr2& operator=(AutoPtr2& ptr2) // not const
{
if(this == &ptr2)
{
return *this;
}
delete this->ptr;
this->ptr = ptr2.ptr;
ptr2.ptr = nullptr;
return *this;
}
T& operator*() const
{
return *this->ptr;
}
T* operator->() const
{
return this->ptr;
}
bool isNull() const
{
return this->ptr == nullptr;
}
private:
T* ptr;
};
struct Resource
{
Resource()
{
std::cout << "Resource acquired" << std::endl;
}
~Resource()
{
std::cout << "Resource destroy" << std::endl;
}
};
int main()
{
AutoPtr2<Resource> res1{new Resource()};
AutoPtr2<Resource> res2;
std::cout << "res1 is " << (res1.isNull() ? "null" : "not null") << std::endl;
std::cout << "res2 is " << (res2.isNull() ? "null" : "not null") << std::endl;
res2 = res1;
std::cout << "res1 is " << (res1.isNull() ? "null" : "not null") << std::endl;
std::cout << "res2 is " << (res2.isNull() ? "null" : "not null") << std::endl;
return 0;
}
上述程序的输出如下：
Resource acquired
res1 is not null
res2 is null
res1 is null
res2 is not null
Resource destroy
我们重载的operator=操作符可以将ptr的所有权从res1转移到res2，res2此时为nullptr，至此采用移动语义解决了上述的问题。
6. 总结
本文通过抛出问题和给出解答的形式引出了移动语义和智能指针，相信通过文中简单的例子能够理解为什么要有移动语义和智能指针。
7. 参考文献
- C++中的RAII机制， https://www.jianshu.com/p/b7ffe79498be
欢迎大家批评指正、评论和转载（请注明源出处），谢谢！
2033
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
