C++ 11 智能指针

时间：2019-04-27 00:37:25 阅读：213 评论：0 收藏：0 [点我收藏+]

标签：自动语义 this 网络 div 申请初始化多线程 ima

C++ 11 智能指针

前言：

　　近来，学习STL，突然发现有智能指针，做了一周的学习（工作之外的时间）,断断续续的学习，特此做下记录。

诞生的原因：

　　　为了防止内存泄露，和二次释放的问题。无非就是嫌弃自己管理内存太费劲，可以写个更简单管理堆内存的类。

利用C++的特性：

　　　类结束会调用析构函数，无非就是栈空间出栈，同时释放掉动态创建的空间。

智能指针的作用：

　　将指针封装成类，利用了一种叫RAII(资源获取即初始化的技术，听着有点高大上)，重载操作符（->和*），行为表现的像指针

防止多次释放该指针，导致崩溃（前提是这个指针被你释放是否赋值为空指针，如果赋值为空，就没有所谓的崩溃问题，习惯决定代码的健壮性）
智能指针作用把值语义转为引用（总是搞个二传手，这就是所谓的安全，降低性能为代价，在内存无比大的今天，随意了）

C++ 11 中的智能指针：

　　包含在头文件<memory>中，分别有三个智能指针，分别为shared_ptr,unique_ptr,weak_ptr。

介绍下shared_ptr(别人写的很好，我只做网络的搬运工，来丰富自己的知识体系)

　　　　1）原理：shared_ptr的多个对象指向同一个指针（大多是new出来的空间指针），该指针使用引用计数，每使用一次，内部计数器加1，每析构一次，内部的引用计数器减1，减为0的时候，自动删除指向的堆内存。

　　　　2）实现：就是一个模板类，没事的时候强烈建议看下里面的具体实现，挺有意思的。

　　　　3）不要用一个原始指针初始化多个shared_ptr,否则会造成二次释放同一内存

4）注意避免循环使用，会在下面举例，并讲解。

　　2.unique_ptr “唯一”拥有所指对象，同一时刻只能有一个unique_ptr指向给定对象（禁止使用拷贝语义，只能用移动语义将其移动）。对比原始指针，也是利用了RAII的特性。用户可以定义delete操作。

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

int main()
{
          unique_ptr<int> uptr(new int(10)); //初始化
          unique_ptr<int> uptr1 = move(uptr); //转移所有权
          uptr2.release();  //释放所有权
          return 0;  
}

　　3.weak_ptr，配合shared_ptr而引入的的智能指针，是弱引用，相对于shared_ptr强引用来说的。看似就像一个观察者，观测资源的使用情况。weak_ptr可以从一个shared_ptr获取另一个weak_ptr来构造，获取资源的观察权。并不会引起计数加的情况，成员有use_count(),查看资源的引用计数，expired()，判断是否指向的资源被释放，当返回为true的时候，这个资源的引用计数为0，相当于被释放，反之就没有被释放掉。lock()，返回当前分享指针，计数器并加1.

#include <iostream>
#include <memory>

using namespace std;
int main()
{
            shared_ptr<int> s_ptr = make_shared<int>(10);
            cout<<s_ptr.use_count() <<endl;
            weak_ptr<int> wp(s_ptr);
            cout<<wp.use_count() <<endl;
            if(!wp.expired())
            {
                   shared_ptr s_ptr2 = wp.lock();  //引用计数器加1
                   *s_ptr = 100;
                   cout<<wp.use_count()<<endl;
             }    
}    

运行结果：
1
1
2

应用场景及其问题：

　　1.循环引用，场景：考虑一个简单的场景--家长和孩子，一个父母有一个孩子，一个孩子有一双父母。

　　使用原始指针的实现：

#include <iostream>
using namespace std;

class Child;
class Parent;

class Parent 
{
private:
    Child* myChild;
public:
    void setChild(Child* ch)
    {
        this->myChild = ch;
    }
    void doSomething() 
    {
        if(this->myChild)
        {
            cout<<"Child alive"<<endl;
        }
    }
    ~Parent() {
        cout<<"delete myChild"<<endl;
        delete myChild;    
}
};

class Child
{
private:
    Parent* myParent;
public:
    void setParent(Parent* p)
    {
        this->myParent = p;
    }
    void doSomething() {
        if(this->myParent)
        {
            
            cout<<"myParent alive"<<endl;                                    }
    }
    ~Child() {
    cout<<"delete myParent"<<endl;
    delete myParent;    
}
};


int main()
{
    Parent* p = new Parent;
    Child* c = new Child;
    p->setChild(c);
    c->setParent(p);
    delete c;
    return 0;
}

　　如何使用智能指针解决该问题呢：引入智能指针，两个类只要保证一个类是shared_ptr（强引用）一个是weak_ptr（弱引用）

#include <memory>
#include <iostream>

class Child;
class Parent;

class Parent{
private:
    std::weak_ptr<Child> ChildPtr;
public:
    void setChild(std::shared_ptr<Child> child)
    {
        this->ChildPtr = child;
    }

    void doSomething() {

    }
    ~Parent() {}
};

class Child {
private:
    std::shared_ptr<Parent> ParentPtr;
public:
    void setParent(std::shared_ptr<Parent> parent) {
        this->ParentPtr = parent;
    }
    void doSomething()
    {}
    ~Child() {}
};


int main()
{
    std::weak_ptr<Parent>  wpp;
    std::weak_ptr<Child> wpc;
    {
        std::shared_ptr<Parent> p(new Parent);
        std::shared_ptr<Child> c(new Child);
        p->setChild(c);
        c->setParent(p);
        wpp = p;
        wpc = c;
        std::cout<<p.use_count() <<std::endl;
        std::cout<<c.use_count() <<std::endl;
    }
    std::cout <<wpp.use_count() << std::endl;
    std::cout << wpc.use_count() << std::endl;
    return 0;
}
运行结果：
2
1
0
0
注意如果使用g++编译，请添加参数-std=c++11(弱引用是C++11引入)

2..返回shared_ptr本身，并不引起计数器加+1

#include<iostream>
#include<memory>

using namespace std;

class Test: public enable_shared_from_this<Test>
{
public:
    Test(){}
    ~Test()
    {cout <<"~Test()"<<endl;}
    shared_ptr<Test> sget()
    {
        return shared_from_this();
    }
};

int main()
{
    weak_ptr<Test> wp;
    {
    shared_ptr<Test> sp(new Test);
    wp = sp;
    cout<<"sp is "<<sp.use_count()<<endl;
    sp->sget();
    cout<<"sp is "<<sp.use_count()<<endl;
    }
    cout<<"wp is"<<wp.use_count()<<endl;
    return 0;

    return 0;
}
运行结果：
sp is 1
sp is 1
~Test()
wp is 0

3.注册销毁函数

#include<iostream>
#include<memory>

using namespace std;

struct MyStruct
{
    int *p;
    MyStruct():p(new int(10)){}
};

int  main()
{
    MyStruct st;
    {
        shared_ptr<MyStruct> sp(&st, [](MyStruct *ptr){
            delete(ptr->p);
            ptr->p = nullptr;
            cout<<"destructed"<<endl;
        });
    }
    if(st.p != nullptr)
        cout<<"no destroyed"<<endl;
    else
        cout<<"be destroyed"<<endl;
    return 0;
}
运行结果:
destructed
be destroyed