C++总结8——shared_ptr和weak_ptr智能指针

http://blog.csdn.net/wendy_keeping/article/details/75268687

智能指针的提出：智能指针是存储指向动态分配对象指针的类，用于生存期控制。能够确保正确销毁动态分配的内存，防止内存泄露。

1.智能指针的分类： 
不带引用计数的智能指针 
auto_ptr unique_ptr scoped_ptr

带引用计数的智能指针 
shared_ptr：强智能指针 
weak_ptr：若智能指针

2.不带引用计数的智能指针是如何确保正确释放堆上内存的？ 
auto_ptr：

auto_ptr<A> ptr1(new A(10));
auto_ptr<A> ptr2 = ptr1;

• 1
• 2

当这两行代码执行完后，ptr1已经不再指向A这个对象，并且ptr1=NULL，ptr1对A对象的所有权已经转移给了ptr2，也就不能通过ptr1调用该类的方法。

vector<auto_ptr<int>> vec;

不能将auto_ptr类型的指针作为STL容器的元素。因为容器避免不了直接拷贝构造和互相赋值。auto_ptr的这种特性会给STL容器的使用造成很大的麻烦。

unique_ptr：

unique_ptr<A> ptr1(new A(10));
unique_ptr<A> ptr2 = ptr1;//error
unique_ptr<A> ptr3 = func();//ok

unique_ptr不支持拷贝构造函数和赋值运算符重载函数，不能隐式的将原指针置为NULL，但是可以通过返回值赋值。unique_ptr支持移动构造函数和移动赋值运算符重载函数，是通过move(C++11标准)函数实现的，用户明确知道对象的所有权已经发生转移，不能再使用原来的指针调用类的方法。这也是auto_ptr和unique_ptr最根本的区别。

scoped_ptr：

scoped_ptr不支持所有权的转移，只能通过该指针对对象进行操作，出作用域会自动析构。

3.带引用计数的智能指针

shared_ptr<A> pa(new A());
shared_ptr<A> pb = pa;

当使用指针指向堆上的对象时，该对象的引用计数加1。拷贝构造或赋值时，不产生该对象的副本，只是更改对象的引用计数。如果别的智能指针也指向这个对象时，也是增加其引用计数。如果delete 指针时，先对引用计数减1，直到对象的引用计数减为0，才调用该对象的析构函数。

4.智能指针的交叉引用导致内存泄露

class A
{
public:
    shared_ptr<B> _pb;
};
class B
{
public:
    shared_ptr<A> _pa;
};


int main()
{
    shared_ptr<A> pa(new A());
    shared_ptr<B> pb(new B());

    pa->_pb = pb;
    pb->_pa = pa;
    return 0;
}

pa指针指向堆上对象后，A的引用计数是1，B的引用计数是1。 
pa->_pb = pb;此时，B的引用计数是2。 
pb->_pa = pa;此时，A的引用计数是2。

出作用域后： 
pb指针释放，B对象的引用计数减1，此时，B的引用计数是1，并不调用B的析构函数。 
pa指针释放，A对象的引用计数减1，此时，A的引用计数是1，并不调用A的析构函数。

程序运行结束，A和B对象并未析构，造成内存泄露

为了避免内存泄露，必须打断这种循环等待的现象。智能指针提供了weak_ptr（弱智能指针）可以避免产生循环等待的现象。

weak_ptr，当用weak_ptr指向对象时，对象的引用计数并不加1，因为弱智能指针没有对对象的使用权，它只有监控权。

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

class A
{
public:
    weak_ptr<B> _pb;
};
class B
{
public:
    shared_ptr<A> _pa;
};


int main()
{
    shared_ptr<A> pa(new A());
    shared_ptr<B> pb(new B());

    pa->_pb = pb;
    pb->_pa = pa;

    return 0;
}

pa指针指向堆上对象后，A的引用计数是1，B的引用计数是1。 
pa->_pb = pb;此时，B的引用计数是1。因为A的成员对象是weak_ptr。 
pb->_pa = pa;此时，A的引用计数是2。

出作用域后： 
pb指针释放，B对象的引用计数减1，此时，B的引用计数是0，调用B的析构函数，先析构自己（B被析构），再析构成员对象（A的引用计数减1，此时A的引用计数是1） 
pa指针释放，A对象的引用计数减1，此时，A的引用计数是0，调用A的析构函数（A被析构）

为了避免智能指针循环引用造成的内存泄露情况，要遵守：创建对象的时候，一定要用强智能指针，其他地方只能用持有资源的弱智能指针。

智能指针本身是线程安全的。使用atomic_increment和atimic_decreament进行对多线程间的互斥，保证引用计数count++/count–是原子操作。

5.多线程访问共享的C++对象产生的线程安全的问题

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

class C
{
public:
    C(){}
    ~C(){}
    void func(){cout<<"call func()"<<endl;}
};

void* threadProc(void *lparg)
{
    shared_ptr<C> pc = (shared_ptr<C>)lparg;
    pc->func();//如果对象已经析构，则程序崩溃！
    return NULL;
}

int main(int argc, char* argv[])
{
    shared_ptr<C> c(new C());
    pthread_t tid;
    pthread_create(&tid, NULL, threadProc, &c);
    return 0;
}

多线程中可能访问共享的对象，如果对象已经析构，线程中访问它，程序会崩溃掉。解决多线程访问共享的C++对象产生的线程安全的问题，可以使用weak_ptr。将弱智能指针转给线程，再访问对象时，先将弱智能和提升为强智能指针，如果提升成功，则说明对象还存在，可以访问该对象的成员变量或方法。如果提升失败，则说明对象已经析构。

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

class C
{
public:
    C(){}
    ~C(){}
    void func(){cout<<"call func()"<<endl;}
};

void* threadProc(void *lparg)
{
    weak_ptr<C> pw = *(weak_ptr<C>*)lparg;
    shared_ptr<C> pc = pw.lock();
//类型提升
    if(pc != NULL)
//类型提升成功，对象未析构
    {
        pc->func();
    }

    return NULL;
}

int main(int argc, char* argv[])
{
    shared_ptr<C> c(new C());

    pthread_t tid;
    weak_ptr<C> pw(c);
    pthread_create(&tid, NULL, threadProc, &pw);
    return 0;
}

创建对象的时候一定要用强智能指针，其他地方只能用持有资源的弱智能指针！！！