程序都是在堆上存储动态分配对象，而它的生存期是由程序来控制的。这就意味着当动态对象不再使用的时候，我们需要显式的将它销毁。
c98提出了一个智能指针auto_ptr为了避免人们使用指针时忘记释放内存。但是因为auto_ptr的总总缺点，使人们在开发过程碰到了各种坑，所以才有了c11新的三个智能指针。
在思考auto_ptr不适用之前我们先思考一下上面叫移动语义？
移动语义是c11提出的，c11最大的特性就是拥有了移动而不是拷贝对象的能力，这就大幅度的提升了性能。
为了让自定义类型的对象也支持移动操作，我们为它定义了移动构造函数和移动赋值运算符。
移动构造函数是对资源进行窃取而不是拷贝。它的第一个参数是该类类型的右值引用，移动构造函数除了完成资源移动外，还必须保证移动之后的原对象处于有效的、可析构的状态（将原对象值赋值给新对象，然后把原对象属性值置空，特别是指针成员置空！那么此时原对象就是处于可析构的安全状态）。
// 拷贝赋值运算符
MemoryBlock& operator=(const MemoryBlock& other)
{
if (this != &other)
{
delete[] _data;
_length = other._length;
_data = new int[_length];
std::copy(other._data, other._data + _length, _data);
}
return *this;
}
// 拷贝构造函数
MemoryBlock(const MemoryBlock& other)
: _length(0)
, _data(nullptr)
{
*this = other;
}
// 移动赋值运算符，通知标准库该构造函数不抛出任何异常
MemoryBlock& operator=(MemoryBlock&& other) noexcept
{
if (this != &other)
{
delete[] _data;
// 移动资源
_data = other._data;
_length = other._length;
// 使移后源对象处于可销毁状态
other._data = nullptr;
other._length = 0;
}
return *this;
}
// 移动构造函数
MemoryBlock(MemoryBlock&& other) noexcept
_data(nullptr)
, _length(0)
{
*this = std::move(other);
}
为什么不适用auto_ptr？
- 缺陷1：auto_ptr缺乏移动语义，它只是单纯的在赋值或构造函数中转移传入的原指针的所有权，并将原指针置空。
auto_ptr<A> pa(new A(123));
pa->print();
//delete pa;
/*智能指针的问题,普通指针肯定没问题*/
auto_ptr<A> pb = pa;//拷贝构造
pb->print();
/*段错误*/ //因为此时pa已经被置空了
pa->print();
-
缺陷2：auto_ptr不能管理对象数组。
对象数组的分配比较不一样，除了分配需要的存储空间之外，堆内存的开头还会分配4个字节的空间来存放对象的个数。
delete[]在原有的数组地址上减去4个字节，取得了真正的初始地址，这样才能正确释放数组。而delete只是用于释放单个对象，不能正确释放数组。我们的auto_ptr的析构函数中使用的是delete
//下面是auto_ptr源码中的析构函数
~auto_ptr() _NOEXCEPT
{
// destroy the object
delete _Myptr;
}
好了，逼逼完前面的一大堆，现在重头戏来了
看了memory里的部分源码，发现有一个在c11之前没有出现过的关键字explict
什么是explict关键字？
有了explict关键字的限定，防止类构造函数进行隐式转换
shared_ptr<int> p1 = new int(1024);
//这种是不行的，因为等号右边是一个int*的指针。
//因为有explict修饰，所以它不能被隐式的转换为shared_ptr<int>的类型
shared_ptr<int> p2(new int(1024));
//这种是直接采用了初始化的形式
- shared_ptr：运行多个指针指向同一对象，是强引用
- unique_ptr：独占指针对象，保证指针所指对象的生命周期与其一致
- weak_ptr：它不能决定对象的生命周期，引用所指对象时，需要lock()成shared_ptr才能使用
unique_ptr
它禁止拷贝语义，但是是通过移动语义（什么是移动语义？上面有解答）来实现的。它“唯一”拥有它所指的对象。
从下面的unique_ptr的构造函数就可以发现它是禁止拷贝语义的。
unique_ptr(const _Myt&) = delete;
_Myt& operator=(const _Myt&) = delete;
但是如果想要切换指针的控制权，可以使用下面的移动构造函数来进行控制权的转化，这里用到forward转发（上一节可以知道forward转发可以返回该参数本来对应的类型的引用），其实这里就是把右值对象移动给左值，并且把右值对象置空
unique_ptr(unique_ptr&& _Right) _NOEXCEPT
: _Mybase(_Right.release(),_STD forward<_Dx>(_Right.get_deleter()))
{ // construct by moving _Right
}
shared_ptr
了解了前面的auto_ptr和unique_ptr，再来理解shared_ptr非常容易。
与前面两者不同的是，shared_ptr允许多个指针指向相同对象，前两者在切换控制权时，会将前面的清除，而shared_ptr不会。
shared_ptr<Base1> base1(new Base1);
shared_ptr<Base1> base2=base1;
shared_ptr<Base1> base3;
base3 = base2;//三个共享一个
当删除其中一个智能指针时，另外两个并不会受到变化。因为此时内存中存在着引用计数，每添加一个shared_ptr，引用计数+1，每次调用析构函数，引用计数-1。直到引用计数减为0，才会释放该块内存。
auto_ptr和unique_ptr都可以通过move函数转换成shared_ptr类型
当使用shared_ptr时，最需要注意的就是避免循环引用，它会造成堆内存无法正常释放，出现内存泄露。如何解决这个问题呢，这时候就要用到weak_ptr的lock()锁
weak_ptr
- weak_ptr是为了配合shared_ptr而引入的，它不存在重载operate*和->。
- 它最大的作用就是协助shared_ptr，像旁观者一样查看资源的使用情况。
- 它可以从一个shared_ptr或另一个weak_ptr对象中构造，获取资源的查看权。
- 它不存在共享资源，所以不会对内存块中的引用计数造成影响。即使weak_ptr也指向同一个内存，但是此时最后一个shared_ptr被销毁，那么对象就会被释放。
shared_ptr<string> s1(new string);
shared_ptr<string> s2 = s1;
weak_ptr<string> w1 = s2;
我们最好在使用weak_ptr访问对象时，使用lock()函数，它可以检测weak_ptr访问的对象是否存在，如果存在，返回一个内存中的shared_ptr对象，不存在，返回一个nullptr的shared_ptr
为什么使用shared_pre会发生循环引用？
当双向链表的前驱指针和后继指针使用了shared_pre，如下
由于使用了shared_pre，一块内存空间有两个对象进行管理，而无法使引用计数为0，那么编译器就无法自动释放内存。
如何解决shared_pre的循环引用？
使用弱引用，弱引用并不会修改对象的引用计数，也就是弱引用并不会对对象的内存进行管理。但是它能检测到引用对象是否被释放，避免了内存泄露。weak_pre就是弱引用。
struct Node
{
weak_ptr<Node> _pre;
weak_ptr<Node> _next;
~Node()
{
cout << "~Node():" << this << endl;
}
int data;
};
void FunTest()
{
shared_ptr<Node> Node1(new Node);
shared_ptr<Node> Node2(new Node);
Node1->_next = Node2;
Node2->_pre = Node1;
cout <<"Node1.use_count:"<< Node1.use_count() << endl;
cout <<"Node2.use_count:"<< Node2.use_count() << endl;
}
int main()
{
FunTest();
system("pause");
return 0;
}
//此时输出的use_count分别为1,1
