C++ 智能指针

一、动态内存管理

动态内存管理经常会出现两种问题：

1. 内存泄漏，忘记释放内存；
2. 非法指针，尚有指针引用内存的情况下就释放了它，就会产生引用非法内存的指针。

因此，引入智能指针。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。
标准库提供两种智能指针：shared_ptr和unique_ptr。区别在于管理底层指针的方法不同，shared_ptr允许多个指针指向同一个对象，unique_ptr则“独占”所指向的对象。标准库还定义了一种名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象，这三种智能指针都定义在memory头文件中。

二、使用方法

注意访问shared_ptr等智能指针的成员函数时用的是“.”，访问指向对象的成员时用的是“->”。

1. unique_ptr

unique_ptr,是用于取代c++98的auto_ptr的产物。

使用需注意：

1. 不能使用两个智能指针赋值操作，应该使用std::move。
2. 可以直接用if(ptest == NULL)来判断是否空指针。
3. 使用函数的返回值赋值时，可以直接使用=, 这里使用c++11 的移动语义特性。
4. 当把它当做参数传递给函数时（使用值传递，应用传递时不用这样），传实参时也要使用std::move,比如foo(std::move(ptest))。
5. 成员函数swap用于交换两个智能指针的值.

class Test
{
public:
    Test(string s)
    {
        str = s;
       cout<<"Test creat\n";
    }
    ~Test()
    {
        cout<<"Test delete:"<<str<<endl;
    }
    string& getStr()
    {
        return str;
    }
    void setStr(string s)
    {
        str = s;
    }
    void print()
    {
        cout<<str<<endl;
    }
	 unique_ptr<Test> fun()
	{
	    return unique_ptr<Test>(new Test("789"));
	}
private:
    string str;
};
int main()
{
    unique_ptr<Test> ptest(new Test("123"));
    unique_ptr<Test> ptest2(new Test("456"));
    ptest->print();// 123
    ptest2 = std::move(ptest);//不能直接ptest2 = ptest，auto_ptr可以; Test delete:456。重点：ptest为空，但并未调用析构函数，内存没有被释放
    if(ptest == NULL) cout<<"ptest = NULL\n";// ptest为空
    Test* p = ptest2.release();//ptest2为空，未调用析构函数，将内容“123”交给p
    p->print();// 123
    ptest.reset(p);//ptest指向p的内存空间，p不变
    ptest->print();// 123
    ptest2 = fun(); //这里可以用=，因为使用了移动构造函数
    ptest2->print();// 789
    return 0;// 释放p，ptest， ptest2内存空间
}

需要注意成员函数release，它只是把智能指针赋值为空，但是原来指向的内存并没有被释放，相当于它只是释放了对资源的所有权，从代码执行结果可以看出，析构函数没有被调用。

2. shared_ptr

从名字share就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。出了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。

创建：

shared_ptr<string> p1;
shared_ptr<list<int>> p2;

make_shared函数：
（最安全的分配和使用动态内存的方法）

shared_ptr<int> p3 = make_shared<int>(42);
shared_ptr<string> p4 = make_shared<string>(10,'9');
shared_ptr<int> p5 = make_shared<int>();

拷贝和赋值：

auto p = make_shared<int>(42);
auto q(p);

我们可以认为每个shared_ptr都有一个关联的计数器，通常称其为引用计数，无论何时我们拷贝一个shared_ptr，计数器都会递增。当我们给shared_ptr赋予一个新值或是shared_ptr被销毁（例如一个局部的shared_ptr离开其作用域）时，计数器就会递减，一旦一个shared_ptr的计数器变为0,它就会自动释放自己所管理的对象。

非智能指针的初始化方法：

int *pi = new int(1024);
string *ps = new string(10,'9');
vector<int> *pv = new vector<int>{0,1,2,3,4,5,6,7,8,9};

shared_ptr和new结合使用：
（必须使用直接初始化形式）

shared_ptr<int> p1 = new int(1024);//错误：必须使用直接初始化形式
shared_ptr<int> p2(new int(1024));//正确：使用了直接初始化形式

get()函数：
访问智能指针包含的裸指针则可以用 get() 函数。由于智能指针是一个对象，所以if (my_smart_object)永远为真，要判断智能指针的裸指针是否为空，需要这样判断：if (my_smart_object.get())。

reset函数：
将一个新的指针赋予一个shared_ptr

shared_ptr<int> p;
p = new int(1024);//错误：不能将一个指针赋予shared_ptr
p.reset(new int(1024));//正确。p指向一个新对象
p.reset();//正确。p释放当前管理的内存

如果不传递参数（或者传递 NULL），则智能指针会释放当前管理的内存。如果传递一个对象，则智能指针会释放当前对象，来管理新传入的对象。

int main()
{
    shared_ptr<Test> ptest(new Test("123"));
    shared_ptr<Test> ptest2(new Test("456"));
    cout<<ptest2->getStr()<<endl;
    cout<<ptest2.use_count()<<endl;
    ptest = ptest2;//"456"引用次数加1，“123”销毁
    ptest->print();
    cout<<ptest2.use_count()<<endl;//2
    cout<<ptest.use_count()<<endl;//2
    ptest.reset();//ptest2.use_count()变为1，但内存未释放
    ptest2.reset();//此时“456”销毁
    cout<<"done !\n";
    return 0;
}

3. weak_ptr

weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。

class B;
class A
{
public:
    shared_ptr<B> pb_;
    ~A()
    {
        cout<<"A delete\n";
    }
};
class B
{
public:
    shared_ptr<A> pa_;
    ~B()
    {
        cout<<"B delete\n";
    }
};
 
void fun()
{
    shared_ptr<B> pb(new B());
    shared_ptr<A> pa(new A());
    pb->pa_ = pa;
    pa->pb_ = pb;
    cout<<pb.use_count()<<endl;
    cout<<pa.use_count()<<endl;
}
 
int main()
{
    fun();
    return 0;
}

可以看到fun函数中pa ，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（A B的析构函数没有被调用）。
解决方法：把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptr<B> pb_; 改为weak_ptr<B> pb_;这样的话，资源B的引用开始就只有1，当pb_析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。 运行结果如下，

注意的是我们不能通过weak_ptr直接访问对象的方法，比如B对象中有一个方法print(),我们不能这样访问，pa->pb_->print(); 英文pb_是一个weak_ptr，应该先把它转化为shared_ptr,如：shared_ptr p = pa->pb_.lock(); p->print();

参考资料

https://www.cnblogs.com/TenosDoIt/p/3456704.html