C++ 资源管理(RAII)--智能指针

1. 智能指针(Smart Pointer)

          i. 是存储指向动态分配（堆）对象指针的类

          ii. 在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象

          iii. RAII类模拟智能指针，见备注

2. C++11提供了以下几种智能指针,位于头文件<memory>，它们都是模板类

          i. std::auto_ptr(复制/赋值)

          ii. std::unique_ptr  c++11

          iii.std::shared_ptr  c++11

          iv.std::weak_ptr    c++11

　　　　　　　　　　g++ -std=c++11 xx.cc

3. std::auto_ptr在构造时获取对某个对象的所有权(ownership),在析构时释放该对象

4. std::auto_ptr要求其对“裸”指针的完全占有性 -> 在拷贝构造或赋值操作时,会发生所有权的转移

5. 本身存在缺陷

6. std::unique_ptr是一个独享所有权的智能指针，它提供了一种严格语义上的所有权，包括：

           i. 拥有它所指向的对象

           ii. 无法进行复制、赋值操作(例题)

           iii.保存指向某个对象的指针，当它本身被删除释放的时候，会使用给定的删除器释放它指向的对象

           iv.具有移动(std::move)语义，可做为容器元素

7. std::shared_ptr是一个引用计数智能指针，用于共享对象的所有权

           i. 引进了一个计数器shared_count,用来表示当前有多少个智能指针对象共享指针指向的内存块

           ii. 析构函数中不是直接释放指针对应的内存块,如果shared_count大于0则不释放内存只是将引用计数减1,只是计数等于0时释放内存

           iii. 复制构造与赋值操作符只是提供一般意义上的复制功能,并且将引用计数加1.

           iv. 在堆内存中只有一份申请的资源，但是有好几个对象都是指向这个内存的资源的。

           v. Shared_ptr的功能就是让不具有值语义的对象拥有值语义，假如说一个对象本身是不希望被复制的，但是要是把这个对象交给shared_ptr管理的时候，使用这个指针的时候就可以对对象进行复制，实际不是真实的对象复制，而是通过一个引用计数的方式去使用。

8. 问题：会有一个问题就是循环引用，会导致内存泄漏。

9. std::shared_ptr是强引用智能指针

10. std::weak_ptr 是弱引用智能指针

11. 强引用，只要有一个引用存在，对象就不能被释放

12. 弱引用，并不增加对象的引用计数，但它知道对象是否存在。如果存在，提升为shared_ptr成功；否则，提升失败

13. 通过weak_ptr访问对象的成员的时候，要提升为shared_ptr

auto_ptr.cc

#include<iostream>
#include<memory>

int main(void)
{
    double *pd = new double(7.77);
    std::auto_ptr<double> apd(pd);  //apd本身是个对象，因为它重载了星号访问运算符，所以可以加* 用。
    //或者std::auto_ptr<double> apd(new double(7.77));

    std::cout << “*apd=” << *apd <<std::endl;
    //通过* 去访问的时候，就相当于对他所托管的指针(pd)所指向的对象进行访问 .
    
    //std::cout << “apd = ” << apd << std::endl;  //会出错，对象不能这样直接打印
    
    std::cout << “apd.get() = ” << reinterpret_cast<long>(apd.get()) << std::endl;    

    double *pd = new double(8.88);
    std::auto_ptr<double> apd2(pd);  
    std::cout << “pd = ” << reinterpret_cast<long>(pd) << std::endl;
std::cout << “apd2.get() = ” << reinterpret_cast<long>(apd2.get()) << std::endl;    //通过get()可以获得原生的指针所在的地址。

    int *pi = new int(7);
    std::auto_ptr<int> api1(pi);
    std::auto_ptr<int> api2(api1);  //复制, 发生了所有权的转移。首先把api1裸指针所指向的值交给了api2, 同时又把api1所指向的值设为了空。相当于api1对pi的所有权完全交给了api2。发生所有权的转移，与常规的认识矛盾。本身有缺陷，不推荐使用。
// std::auto_ptr要求其对“裸”指针的完全占有性在拷贝构造或赋值操作时,会发生所有权的转移

std::cout << “*api1= ” << *api1 <<std::endl;  //现在访问api1指向的值，发现没有了，发生一个段错误。
    std::cout << “*api2 = ” << *api2 <<std::endl;
    

    return 0;
}

unique_ptr.cc

#include<iostream>
#include<memory>
#include<vector>


std::unique_ptr<int> getVal()   //这里返回一个unique_ptr对象，这个对象是个右值。
{ 
    std::unique_ptr<int> up(new int(66));
    return up;
}

int main(void)
{
    // 无法进行复制、赋值操作
    std::unique_ptr<int> ap(new int(99));
    //std::unique_ptr<int> one(ap);   //编译出错，不能够进行复制。

    std::unique_ptr<int> two;
    //two = ap;  //编译出错，不能进行赋值。

    std::cout << “*ap = ” << *ap << std::endl;
    std::cout << “ap.get() = ” << reinterpret_cast<long>(ap.get())  << std::endl;  //获取指针的值
    
    //可以进行移动构造和移动赋值操作
    std::unique_ptr<int> up = getVal();   //getVal()函数返回一个右值，这个右值会优先绑定到右值引用上去。unique_ptr是具有移动语义的，意思就是说它提供了一个移动构造函数和一个移动赋值函数。而这里就优先调用了移动赋值函数。并没有调用复制构造函数。
    std::cout << “*up = ” << *up << std::endl;


    //实际上上面的操作有点类似于如下操作
    Unique_ptr<int> up(int new int(99));
    Unique_ptr<int> uPtr2 = std::move(up);  //这里是显式的所有权转移。把up所指的内存转给uPtr2了，而up不再拥有该内存。


    
    //可以作为容器的元素(就是因为具有移动语义)
    std::unique_ptr<int> sp(new int(55));  //sp现在是一个左值，就要绑定到复制构造函数上面去，因为复制构造函数的参数是一个左值引用。
    std::vector<std::unique_ptr<int> vec;
    //vec.push_back(sp);   //会出错，因为会调用复制构造函数
    vec.puch_back(std::move(sp));  //将左值转成右值引用，这时就会调用 移动构造函数，而不是 复制构造函数。
    std::cout << *vec[0] << std::endl;  //打印刚添加的值。

    return 0;
}

Shared_ptr.cc

    #include<iostream>
    #include<memory>
    
    class Child;
    class Parent;

    typedef std::shared_ptr<Child> Child_ptr;
    typedef std::shared_ptr<Parent> Parent_ptr;

    class Child
    {
    public:
        Child()
         {
            std::cout << “Child()” << std::endl;
}
~Child()
         {
            std::cout << “~Child()” << std::endl;
}
     //private:    
        Parent_ptr parent_;
};
    
    class Parent
    {
    public:
        Parent()
        {    
            std::cout << “Parent()” << std::endl;
}
~Parent()
        {    
            std::cout << “~Parent()” << std::endl;
}

    //private:
        Child_ptr child_;
};

int main(void)
{
    Parent_ptr parent(new Parent);  //交给shared_ptr进行管理
    Child_ptr child(new Child);    

    std::cout << “parent’s count = ”  << parent.use_count() << std::endl;
    std::cout << “child’s count = ” << child.use_count() << std::endl;

    std::cout << “进行复制之后：” << std::endl;
    parent->child_  = child;      //shared_ptr复制操作
    std::cout << “child’s count = ” << child.use_count() << std::endl;  //打印出引用计数为2.
    child->parent_ = parent;
    std::cout << “parent’s count = ”  << parent.use_count() << std::endl;   //打印出引用计数为2.
    
    return 0;
}
    //因为相互引用，当程序结束时，引用计数都减一，都成为1。内存中还有这两个对象的存在，就不会调用析构函数。这样就带来了内存泄漏，是循环引用存在的问题。

weak_ptr1.cc

    #include<iostream>
    #include<memory>
    
    class Child;
    class Parent;

    typedef std::shared_ptr<Child> Child_ptr;
    typedef std::shared_ptr<Parent> Parent_ptr;

    class Child
    {
    public:
        Child()
         {
            std::cout << “Child()” << std::endl;
}
~Child()
         {
            std::cout << “~Child()” << std::endl;
}
     //private:    
        Parent_ptr parent_;
};
    
    class Parent
    {
    public:
        Parent()
        {    
            std::cout << “Parent()” << std::endl;
}
~Parent()
        {    
            std::cout << “~Parent()” << std::endl;
}
    
std::weak_ptr<Child> child_;  //弱引用
};

int main(void)
{
    Parent_ptr parent(new Parent);  //交给shared_ptr进行管理
    Child_ptr child(new Child);    

    std::cout << “parent’s count = ”  << parent.use_count() << std::endl;
    std::cout << “child’s count = ” << child.use_count() << std::endl;

    std::cout << “进行复制之后：” << std::endl;
    parent->child_  = child;      //child_是weak_ptr,引用计数并没有加1
    std::cout << “child’s count = ” << child.use_count() << std::endl;  //打印出引用计数为2.
    child->parent_ = parent;
    std::cout << “parent’s count = ”  << parent.use_count() << std::endl;   //打印出引用计数为2.
    
    return 0;
}
    //因为使用的是弱引用，复制的时候引用计数不会加1. 程序结束时会调用析构函数。

Weak_ptr.cc

#include<iostream>
#include<memory>

class X
{
public:
    X() {std::cout << “X()” << std::endl;}
    ~ X() {std::cout << “~X()” << std::endl;}

    void fun()
    {
        std::cout << “fun()” << std::endl;
}
};

int main(void)
{
    std::weak_ptr<X> p;
    {
        std::shared_ptr<X> p2(new X);  //所有new出来的东西都放到这个栈对象p2里面，因为当这个语句块结束的时候p2会调用析构函数，我们在析构函数中加上delete来释放托管过来的指针。
        std::cout << “p2’s count = ” << p2.use_count() <<std::endl;

        p = p2;  //std::weak_ptr 不会增加引用计数
        std::cout << “after p = p2 ” <<std::endl;
        std::cout << “p2’s count = ” << p2.use_count() <<std::endl;

        std::shared_ptr<X> p3 = p.lock();  //lock()函数就是用来提升weak_ptr为shared_ptr的函数。
    
    if(p3) //提升成功
    {
        p3->fun();
            std::cout << “p3’s count = ” << p3.use_count() <<std::endl;
}
else  //提升失败
{
    std::cout << “object has been destroied” << std::endl;
}
}

//new X 已经被释放了
//通过weak_ptr访问对象的成员的时候，要提升为shared_ptr
std::shared_ptr<X> p4 = p.lock();  
if(p4) //提升成功
{
    P4->fun();
        std::cout << “p4’s count = ” << p4.use_count() <<std::endl;
}
else  //提升失败
{
std::cout << “object has been destroied” << std::endl;
}

//智能指针作为栈对象来使用，不要采用堆对象的方式来使用。因为智能指针作为栈对象来使用，它可以具有自动管理、自动回收的功能。
//智能指针的实现原理：栈对象生命周期结束的时候，会自动调用析构函数。
//std::shared_ptr<X> *pthis = new std::shared_ptr<X>(new X);
//上述方式就是生成堆对象，不推荐这么做。而且这时候只能通过显示调用delete函数，这样就跟我们的初衷不符。

    return 0;
}