大厂面试重要C++知识（三）—— 智能指针

一、前言

• C/C++最让人诟病的特性之一：内存泄漏。因此如java、C#等语言都提供了内置内存分配与释放功能，屏蔽了指针。自动分配内存还是手动分配内存都有利有弊，而智能指针为解决内存泄漏问题应运而生。
• 内存泄漏的案例：如我们new了一个对象在堆区开辟了空间，需要在一定位置将其delete释放空间，但是程序可能在未执行到delete语句时就已经跳转或返回了，从而造成内存泄漏。而如果使用智能指针，因为智能指针本质是一个类，当超过类的作用域时，类会自动调用析构函数释放内存，从而避免内存泄漏。
• 内存泄漏，如遇到try/catch异常处理模块，发生异常时可能并不会delete销毁内存。

二、智能指针

• 最早提出的智能指针是std::auto_ptr，在C++03版本标准库第一次引入。当时只有std::auto_ptr，然而在C++11，std::auto_ptr被抛弃，引入了：std::unique_ptr、std::share_ptr、std::weak_ptr。
• 智能指针：头文件 #include

三、auto_ptr

首先，定义一个类Test，用于以下各类的智能指针。

class Test
{
public:
    Test(string s)
    {
        str = s;
        cout << "Test create" << endl;
    }
    ~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基本操作

• auto_ptr智能指针其实是个模板类，创建的方式和模板类似，<>里写入参数，在这里将之前的类Test写入，创建Test的智能指针。创建一个智能指针后，就可以像创建类的指针一样调用Test对象了。
• 智能指针ptest调用Test类的方法时用->，而调用智能指针本身的方法如get、reset时使用.。
• reset方法，可以将智能指针指向一个新的空间，原有空间将释放。

#include 
using namespace std;

int main()
{
    auto_ptr<Test> ptest(new Test("123"));
    ptest->print();
    ptest.get()->print();
    cout << "######################" << endl;
    ptest->setStr("hello ");
    ptest->getStr() += "world!";
    (*ptest).print();
    cout << "######################" << endl;
    ptest.reset(new Test("123"));
    ptest->print();

    return 0;
    
}

智能指针赋值

• 创建两个智能指针ptest1和ptest2，将ptest1赋值给ptest2，ptest2 = ptest1，对于auto_ptr来说，ptest2将接管ptest1的内存管理，ptest1指针变为NULL，ptest2原来的内存析构。注意：判断一个智能指针是否为空使用if(ptest1.get() == NULL)。
• ptest.release()将ptest的赋值设为空，但是不释放资源，可用reset释放。

int main()
{
    auto_ptr<Test> ptest1(new Test("123"));
    auto_ptr<Test> ptest2(new Test("456"));
    
    ptest2 = ptest1;
    ptest2->print();
    if (ptest1.get() == NULL)
    {
        cout << "ptest1 is NULL" << endl;
    }
    return 0;
}

​

四、unique_ptr

• unique_ptr，用来取代auto_ptr的产物。
• unique_ptr和auto_ptr十分相似，不过不能使用两个智能指针直接赋值操作，需要使用std::move()函数。
• 可直接用if(ptest == NULL)来判断是否为空指针。
• 可以使用swap交换两个元素

int main()
{
    unique_ptr<Test> ptest1(new Test("123"));
    unique_ptr<Test> ptest2(new Test("456"));
    ptest1->print();
    ptest2->print();
    ptest1.swap(ptest2);
    ptest1->print();
    ptest2->print();

    ptest2 = std::move(ptest1);//不可直接ptest2 = ptest1
    if (ptest1 == NULL)
        cout << "ptest1 is NULL" << endl;

    Test* p = ptest2.release();
    p->print();
    ptest1.reset(p);
    ptest1->print();

    return 0;
}

五、share_ptr

• 从名字share可见资源是共享的，通过计数机制表明资源被几个指针共享。当进行拷贝或赋值操作时，每个shared_ptr都会记录有多少个其他shared_ptr指向相同的对象。

• 通过函数use_count()查看资源所有者的个数。

• 调用reset函数时，当前指针会释放资源所有权，计数减一。当计数为0，资源会被释放。即当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象。

• shared_ptr智能指针可以通过make_shared分配动态内存。

int main()
{
    shared_ptr<Test> ptest1(new Test("123"));
    shared_ptr<Test> ptest2 = make_shared<Test>("456");
    cout << ptest2->getStr() << endl;
    cout << ptest2.use_count() << endl;
    cout << "######################" << endl;
    ptest1 = ptest2;    //"456"加1，"123"销毁
    //两者都是"456"
    cout << ptest2->getStr() << endl;
    cout << ptest1->getStr() << endl;
    cout << ptest1.use_count() << endl;
    cout << ptest2.use_count() << endl;
    cout << "######################" << endl;
    ptest1.reset();
    cout << ptest2.use_count() << endl;
    ptest2.reset();
    cout << ptest2.use_count() << endl;

    return 0;
}

• 可以看到，ptest1 = ptest2时，ptest1对应的"123"销毁，ptest1和ptest2共享"456"对应的内存，这和之前的auto_ptr和unique_ptr不一样，之前的两个智能指针的在赋值后ptest1变为空。

六、weak_ptr

• weak_ptr用于解决shared_ptr相互引用时的死锁问题，即两个指针的引用个数永远不会减小到0，资源不会被释放。

• weak_ptr是对对象的一种弱引用，不会增加对象的引用计数，可以和shared_ptr之间互相转换，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。

class B;
class A
{
public:
    shared_ptr<B> pb;
    ~A()
    {
        cout << "A delete" << endl;
    }
};
class B
{
public:
    shared_ptr<A> pa;
    ~B()
    {
        cout << "B delete" << endl;
    }
};

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；跳出fun()函数时，智能指针pa、pb析构两个资源的引用减一，但是两者资源依旧是1，也就是类A和类B中的两个资源引用没有减1，从而造成内存泄漏。

解决互相引用问题

​  解决办法是，其中一个类的智能指针用weak_ptr替代。比如，将A的shared_ptr< B > pb改为weak_ptr< B > pb。

• 开始，资源B的引用为1，资源A的引用为2;
• 跳出fun()函数时，pb析构，B的引用减一为0，B资源释放，pb中的智能指针资源A也被释放，A - 1 = 1；
• 这时候A等于1，pa再析构后，A - 1=0，A资源得到释放。

class B;
class A
{
public:
    weak_ptr<B> pb;
    ~A()
    {
        cout << "A delete" << endl;
    }
};
class B
{
public:
    shared_ptr<A> pa;
    ~B()
    {
        cout << "B delete" << endl;
    }
    void show()
    {
        cout << "hello" << endl;
    }
};

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;
    
    
    shared_ptr<B> test = pa->pb.lock();
    test->show();
}

• 可以看到，利用weak_ptr后，A和B最终得到析构，释放了空间。

• 而要想访问weak_ptr，我们可以用lock()方法得到weak_ptr智能指针，再进行访问。

七、总结

  从以上各种智能指针的用法可以总结，我们使用智能指针其实是利用其对象的性质，对于智能指针本身并不需要new，而对需要操作的元素new出空间。而智能指针在函数结束后就会调用析构函数，new出的元素也会被释放，从而解决了内存泄漏的问题。