智能指针

什么是智能指针？
智能指针就是智能（自动）的管理所指向的的内存资源的释放。因为我们自己开辟内存后，使用普通指针的时候最后常常忘了释放资源，导致内存泄漏！
智能指针本身并不是一个指针，他是一个类，重载了“ * ” “->“,能让我们像指针一 样去使用，最核心的思想就是RAII机制:获得资源立即初始化。定义一个类，在构造函数中实现资源的分配和初始化，析构函数中释放资源。这样一来，对象出了作用域会自动调用析构函数，资源就得到释放，不会有内存泄漏的问题了。
智能指针通用的实现技术是引用计数，将一个计数器和类对象关联，记录着有多少个类对象（智能指针）指向同一块内存资源。每当创建对象时，引用计数的值为1，当用该对象去拷贝构造另一个对象时，就将引用技术的值加1；当用当前对象给另一对象赋值时；赋值运算符的左操作数的引用计数值减1，右操作数的应用计数值加1。如果一个对象引用计数值为0，就删除该对象；析构函数就是把对象的引用计数值减1，如果减到了0，就删除该对象

常见的智能指针及发展历史

auto_ptr

auto_ptr是出现最早的智能指针，在C++98标准中已经存在。
quto_ptr特点: 独占资源的管理权限,解决内存泄漏的问题，但是也可能会引起其他问题。

1. 重复释放的问题：

int *t = new int(10);
auto_ptr<int> p1(t);
auto_ptr<int> p2(t);

这是很严重的问题;如果多个auto_prt同时管理同一对象，他们都认为这块空间是归自己管，第一个auto_ptr生命周期结束后自动释放了资源，而后来的auto_ptr也会自动释放。例如：p1,p2都管理着t,在析构时都会删除 t ,这就造成了重复释放的问题,这比内存泄漏还严重，因为再次释放的空间已经被别人用着，你释放了别人的空间，这在c++中式致命错误。
2. 解引用NULL指针的问题（双刃剑，也能解决浅拷贝的问题）

情况一：
    auto_ptr<int> p1(new int(10));
    auto_ptr<int> p2;
    p2 = p1;
    cout << "*p2 is " <<*p2 << endl;
    if (p1.get() == NULL) //get()方法式返回保存的指针
        cout << "p1 is NULL" << endl;
    //cout << *p1 << endl；这条语句运行，程序就崩溃了

情况二：
void fun(auto_ptr<int> p)
{
    //....
}
int main()
{
    int *a = new int(10);
    auto_ptr<int> p1(new int(10));
    fun(p1);
    //cout<<*p1<<endl;//代码崩溃
}
因为管理权转移，在调用fun函数时候，存在一次值拷贝，就把权限给了临时变量，
出了fun函数作用域，临时变量自动销毁，所以调用了析构函数释放了资源.

所以值得注意的就是，auto_ptr进行赋值之后，“ =”右边的auto_ptr就是NULL指针了，他把管理权限已经给了别人，不能再对它进行解引用操作了。

为什么是双刃剑,可以解决浅拷贝的问题？

浅拷贝是指原对象和拷贝对象共用同一份实体；假如类两个对象里有包含了指针，如果我们不写拷贝构造，会调用默认的拷贝构造，而默认的是浅拷贝，这样不但破坏了类的封装性，还会带来很多问题。但是我们使用auto_ptr不会这样，因为它把所有权转移之后，它就为NULL了，我们看个例子就明白了；

class AA{
public:
    AA(int data)
    {
        _ptr = new int(data);
    }
private:
    int *_ptr;
};

int main()
{
    AA a1(10);
    AA a2(a1);
    AA a3;
    a3 = a1;//这里的a1,a2,a3都是同一个对象，每个对象的_ptr都指向同一块内存
    auto_ptr<AA> p1(AA(100));
    auto_ptr<AA> p2(p1);//所有权转移，p1为null
    auto_ptr<AA> p3;
    p3 = p2;//所有权转移，p2为null
    return 0;
}

3.不能用auto_ptr管理数组

auto_ptr<int> p(new int[10]);//错误的用法

auto_ptr的析构函数用的是delete，不是delete[];所以不能用来管理数组，否则会内存泄漏；虽然代码可以通过，但是我们不能这么用。
4，不能用做vector,list,map容器的元素（STL容器分配内存时，必须要拷贝容器元素的值，并且不能修改；而auto_ptr在拷贝构造的时候一定会修改元素的值，使auto_ptr的对象变为指向NULL）
原因比较复杂，详情参考：

https://blog.csdn.net/messiran10/article/details/52269813

unique_ptr

c++11标准中就有了3中智能指针了（unique_ptr,shared_ptr,weak_ptr）
针对auto_ptr的缺陷，unique_ptr是在其上的升级版本；
基本操作：

1. get():获得原生指针
2. reset():重置，释放资源；reset(new xxx);释放原来资源，重新指定对象
3. release()：释放所有权到某一原生指针上 ；

禁止赋值和复制
他唯一的拥有其所指对象，同一时刻只能由unique_ptr指向给定对象。模板类中它将拷贝构造函数和赋值运算符重载（“=”）设置成了私有成员。所以是无法使用的。

//以下代码是错误的，编译通不过
unique_ptr<AA> p1(new AA（10）)；
unique_ptr<AA> p2(p1);//错误，编译报错 
unique_ptr<AA> p3;
p3 = p1;//错误，编译报错

管理数组指针

unique_ptr<int []> p(new int[10]);

可以做vector,list map等容器元素

vector<unique_ptr<int>> v;
unique_ptr<int> p1(new int(10));
v.push_back(std::move(p1));
//v.push_back(p1);这是错误的，STL容器会拷贝元素的值，而unique_ptr不允许拷贝；

shared_ptr

shared_ptr也叫做共享指针，用到了引用计数机制，有个use_cout成员，表示了当前有多少个shared_ptr指向了同一个对象，在拷贝构造和赋值运时引用计数加1；直到引用计数的值变为0时，调用析构函数释放资源。

    shared_ptr<int>p1(test);
    shared_ptr<int>p2(p1);
    shared_ptr<int>p3;
    p3 = p2;
    int count1 = p1.use_count();
    int count2 = p2.use_count();
    int count3 = p3.use_count();

经过不断发展，c++11中的shar_ptr基本能满足我们的使用了，之前的不足和缺陷也能修补；但是金无足赤，shared_ptr也有缺陷——-出现循环引用的问题。

什么是循环引用？

举个例子：

“`
class B;
class A
{
public:
A()
:pb(NULL)
{}
shared_ptr pb;
};

class B
{
public:
B()
:pa(NULL){}
shared_ptr pa;
};

int main()
{
shared_ptr p1(new A());
shared_ptr p2(new B());
p1->pb = p2;
p2->pa = p1;

int count1 = p1.use_count();//2
int count2 = p2.use_count();//2
return 0;

}
“`
我们看到p1，p2他们所指对象的引用计数的值都是2，当程序结束后，引用计数的值变为1，并不会释放资源，这就导致资源泄漏的问题。
解决这种问题的方法：

• 当最后引用计数的值还为1，手动打破循环引用释放资源。
• 使用weak_ptr

weak_ptr

weak_ptr是为了解决shared_ptr循环引用的问题的智能指针；他就像一个助手，配合shared_ptr；他不会去管理资源，拷贝构造时引用计数也不会加1；没有重载 “ * ”和 -> ”，但是可以用lock获取一个可用的shared_ptr对象

• 它只有资源的观察权，没有资源的托管权。获取资源观察权的方法是使用另一个 shared_ptr 或者 weak_ptr 去构造。
• 成员函数 use_count 可以获取被观察资源的引用计数，expire函数表示被观察的资源已经不复存在，lock成员用于获取被观察的shared_ptr对象，如果expire()==true，则lock函数将返回一个存储空指针的shared_ptr。

#include <iostream>
#include <memory>
using namespace std;

void Check(weak_ptr<int> &wp)
{
    shared_ptr<int> sp = wp.lock(); // 重新获得shared_ptr对象
    if (sp != nullptr)
    {
        cout << "The value is " << *sp << endl;
    }
    else
    {
        cout << "Pointer is invalid." << endl;
    }
}

int main()
{
    shared_ptr<int> sp1(new int(10));
    shared_ptr<int> sp2 = sp1;
    weak_ptr<int> wp = sp1; // 指向sp1所指向的内存

    cout << *sp1 << endl;
    cout << *sp2 << endl;
    Check(wp);

    sp1.reset();
    cout << *sp2 << endl;
    Check(wp);

    sp2.reset();
    Check(wp);

    system("pause");
    return 0;
}