c++智能指针用法

智能指针是什么

智能指针是
c++中有四个智能指针:auto_ptr、shared_ptr、weak_ptr、unique_ptr，其中后三个是c++11支持，并且第一个已经被c++11弃用。
智能指针是一个RAII(Resource Acquisition is initialization)类模型，用来动态的分配内存。当超出类的作用域时，类会自动调用析构函数，析构函数会自动释放资源。
举例:当我们写一个new语句时，一般会立即把delete语句也直接写入，但是不能避免程序还未执行到delete时就跳转或在函数没有执行到最后的delete语句就返回了，如果不在每一个可能跳转或返回的语句前释放资源，就会造成内存泄露，使用智能指针可以很大程度避免这个问题。
auto_ptr的类模板原型为：

templet<class T>
class auto_ptr {
  explicit auto_ptr(X* p = 0) ; 
  ...
};

• 定义一个类

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;
    }
private:
    string str;
};

• auto_ptr智能指针

1. auto_ptr访问自己的成员函数用.，访问指向对象的成员时用->
2. 对智能指针进行赋值时，ptest2 = ptest;。此时ptest2会接管ptest原来的内存管理权，ptest会变成空指针；如果ptest2原来不为空，则它会释放原来的资源。判断一个智能指针是否为空不能用if(ptest == NULL)，应该用if(ptest.get() == NULL)。
3. auto_ptr的成员函数release，作用:把智能指针赋值为空，只释放对资源的所有权，原来指向的内存并不被释放。
4. 若中途想释放资源，可以使用ptest.reset();，就不用等到智能指针被析构时释放。

int main()
{
    auto_ptr<Test> ptest(new Test("123"));
    auto_ptr<Test> ptest2(new Test("456"));
    ptest2 = ptest;
    ptest2->print();
    if(ptest.get() == NULL)cout<<"ptest = NULL\n";
    ptest->setStr("hello ");
    ptest->print();
    ptest.get()->print();
    ptest->getStr() += "world !";
    (*ptest).print();
    ptest.reset(new Test("123")); //重新绑定指向的对象，原来的对象会被释放
    ptest->print();
    return 0;
}

• unique_ptr智能指针

1. 独享所有权，拥有它指向的对象
2. 无法进行复制构造，无法使两个unique_ptr指向同一个对象。应该用std::move()
3. 保存指向某个对象的指针，当它本身被删除释放的时候，会使用给定的删除器释放它指向的对象。
   4)可以用if(ptest == NULL)来判断是否空指针；

unique_ptr<Test> fun()
{
    return unique_ptr<Test>(new Test("789"));
}
int main()
{
    unique_ptr<Test> ptest(new Test("123"));
    unique_ptr<Test> ptest2(new Test("456"));
    ptest->print();
    ptest2 = std::move(ptest);//不能直接ptest2 = ptest
    if(ptest == NULL)cout<<"ptest = NULL\n";
    Test* p = ptest2.release();
    p->print();
    ptest.reset(p);
    ptest->print();
    ptest2 = fun(); //这里可以用=，因为使用了移动构造函数
    ptest2->print();
    return 0;
}

编译运行结果:

image.png

• share_ptr智能指针

1. 资源可以被多个指针共享，使用计数机制表明资源被几个指针共享。通过成员函数use_count()来查看资源的所有者个数。
2. 调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。

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.reset();//此时“456”销毁
    cout<<"done !\n";
    return 0;
}

image.png

• weak_ptr智能指针

1. 用来解决shared_ptr相互引用时的死锁问题，若两个shared_ptr相互引用，那么这两个指针的引用计数永远不可能下降为0，资源永远不会释放。
2. 是对对象的一种弱引用，不会增加对象的引用计数，和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的析构函数没有被调用)。运行结果如下:

image.png

若把类A中的shared_ptr<B> pb_改为weak_ptr<B> pb_，资源B的引用开始只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。编译运行结果如下:

image.png

2. 是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，通过调用lock函数获得shared_ptr.不能通过weak_ptr直接访问对象。
   若B对象中有一个方法print()，不能通过如下方式访问

pa->pb_->print()

因为pb_是一个weak_ptr，应先把它转换为shared_ptr。

shared_ptr<B> p = pa->pb_.lock();
p->print();

参考大佬博客