内存垃圾管理（智能指针）

---

智能指针 shared_ptr：
https://blog.csdn.net/u012501459/article/details/48229399

C++11中引入了智能指针的概念。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，使用智能指针能更好的管理堆内存。

• 构造函数中创建类的新对象时，初始化引用计数为1；
• 拷贝构造函数复制指针，并使相应的引用计数增加1；
• 赋值操作减少左操作数所值对象的引用计数，增加右操作数所指对象的引用计数；

• 析构函数使引用计数减少1，并且当引用计数为0时，释放指针说指向的对象；

  
  image.png

定制删除器：

#include<iostream>
#include<memory>
using namespace std;
int main(){
    shared_ptr<int> sp1(new int(10));
    cout<<*sp1<<endl;
    *sp1 = 20;
    cout<<*sp1<<endl;
        return 0;
}

我们动态申请的内存,构造时完成初始化，析构时通过delete来释放没有任何问题。但是文件指针可能就挂了。

#include<iostream>
#include<memory>
using namespace std;
int main(){
    shared_ptr<FILE> sp1(fopen("test.txt","w"));
    //如果不进行任何特殊处理,则程序崩溃!
    return 0;
}

因此，shared_ptr提供了删除器功能，我们可以通过定制删除器，来对特定的资源进行回收。

#include<iostream>
#include<memory>
using namespace std;
 
//仿函数
struct Fclose{
    void operator()(void *ptr){
        fclose((FILE*)ptr);
        cout<<"不用担心,shared_ptr已经通过调用我关闭了文件!"<<endl;
    }
};
 
int main(){
    //我们通过传入仿函数,来完成对文件指针的清理
    shared_ptr<FILE> sp1(fopen("test.txt","w"),Fclose());
    return 0;
}

---

Ref_ptr类：

//使用int*指针初始化ptr，注意必须要放在初始化列表中
Ref_ptr(int * i):ptr(new Referenced(i))
{

}
//拷贝构造函数，又有一个变量指向了这块内存
Ref_ptr(const Ref_ptr & rhs)
{
    ptr=rhs.ptr;//将右操作数的引用计数对象赋值给左操作数
    ptr->ref();//将它们的应用计数加1
}

Ref_ptr r1=new int(4); //调用构造函数
Ref_ptr r2=r1; //调用拷贝构造函数

image.png

//赋值操作符，右操作数的引用计数要减1，左操作数的引用计数要加1
Ref_ptr & operator=(const Ref_ptr & rhs)
{
    if(&rhs==this)
        return *this;
    if(ptr->unref()==0)//赋值操作符，首先将当前类的引用计数减1，因为现在指向它的指针少了一个。
    {
        cout<<"delete Ref_ptr"<<endl;
        delete ptr;
    }
    ptr=rhs.ptr; //将右操作数的引用计数赋值给当前对象
    ptr->ref(); //引用计数加1
    return *this;
}

//析构函数，引用计数要减1，如果减为0，删除这块内存
~Ref_ptr()
{
    if(ptr->unref()==0)
    {
        cout<<"delete Ref_ptr"<<endl;
        delete ptr;
    }
}

---

Referenced类：

//初始化这个类，引用计数设为1，并且将p指向传入的地址
Referenced(int * pi)
{
    refCount=1;
    p=pi;
}

//引用计数加1
int ref()
{
    return ++refCount;
}   

//引用计数减1
int unref()
{
    return --refCount;
}

//析构函数，释放掉内存
~Referenced()
{
    cout<<"delete referenced"<<endl;
    delete p;
}

---

好处：

• 智能指针能够帮助我们处理资源泄露问题；
• 它也能够帮我们处理空悬指针的问题；
• 它还能够帮我们处理比较隐晦的由异常造成的资源泄露。

循环引用：

image.png image.png

#include <memory>
class B;
class A
{
public:
    ~A()
    {
        printf("delete A");
    }
    std::shared_ptr < B >
        m_b;
};
 
class B
{
public:
    ~B()
    {
        printf("delete B");
    }
    std::shared_ptr < A >
        m_a;
};
 
int main()
{
    std::shared_ptr<A> a(new A); //new出来的A的引用计数此时为1
    std::shared_ptr<B> b(new B); //new出来的B的引用计数此时为1
    a->m_b = b; //B的引用计数增加为2
    b->m_a = a; //A的引用计数增加为2
}