RALL资源获取初始化，删除器

body, table{font-family: 微软雅黑; font-size: 10pt}
table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;}
th{border: 1px solid gray; padding: 4px; background-color: #DDD;}
td{border: 1px solid gray; padding: 4px;}
tr:nth-child(2n){background-color: #f8f8f8;}

资源管理--RAII：

1、RAII(Resource Acquisition Is Initialization)是一种由 C++创造者 Bjarne Stroustrup 提出的， 利用对象生命周期管理程序资源（包括内存、文件句柄、锁等）的技术。

2、使用 RAII 时，一般在资源获得的同时构造对象， 在对象生存期间，资源一直保持有效；对象析构时，资源被释放。

关键：要保证资源的释放顺序与获取顺序严格相反

3、RAII类的常见特征

1、在构造时初始化资源， 或托管已构造的资源

2、析构时释放资源

3、一般不允许复制或赋值(对象语义)

4、提供若干访问资源的方法

4、RAII的本质是用栈对象来管理资源，因为栈对象在离开作用域时，会自动调用析构函数

#include <iostream> #include <stdio.h> #include <string> using namespace std; class SafeFile {         public:                 SafeFile(const string & filename)                 :_fp(fopen(filename.c_str(),"w+"))                 {                         cout<<"fopen(_fp)"<<endl;                         if(NULL == _fp)                         {                                 cout<< "FILE open error"<<endl;                         }                 }                 ~SafeFile()                 {                         if(_fp != NULL)                         {                                 fclose(_fp);                                 cout<< "fclose(_fp) "<<endl;                         }                 }

void write(const char * str)                 {                         cout<<"write(const char *)"<<endl;                         if(fputs(str,_fp)==EOF)                         {                                 cout<< "write error!" <<endl;                         }                 }         private:                 FILE * _fp;                 SafeFile(const SafeFile & rhs);                 SafeFile & operator = (const SafeFile & rhs); }; int main() {         SafeFile sf("test.txt");         sf.write("hello,world!\n");         return 0; }

/** **利用一个对象在离开个域中会调用析构函数的特性， **在构造函数中完成初始化，在析构函数中完成清理工作，将需要 **操作和保护的指针作为成员变量放入RAII中。 */ #include<iostream> using namespace std; template<typename T> class RALL {         public:                 RALL(T* p):_p(p)  { cout<<"托管资源"<<endl; }                 ~RALL()  // 托管资源，可能多个指针指向同一块内存区域，if判断不能发挥作用                 {                         if(NULL!=_p)                         {                                 delete _p;                                 _p=NULL;                         } cout<<"释放资源"<<endl;                 }                 // 资源指针，被托管的都是资源的地址，                 // 所以要重载这些运算符，能够获取                 // 资源的地址                 T* get()const;             T& operator*()const;  //目的就是返回托管的指针指向的值             T* operator->()const;  // 似乎没怎么用到这个                 void reset(T* new_p);  // 更改托管资源地址                 void swap(RALL<T> &rhs);  // 交换地址         private:                 RALL(const RALL<T>&);  //禁止调用拷贝构造函数                 RALL<T>& operator=(const RALL<T>&);  // 禁止调用赋值构造函数         private:                 T* _p;  // _p指向被托管的资源 }; template<typename T> T* RALL<T>::get()const {         return _p; } template<typename T> T& RALL<T>::operator*()const {         return *_p; } template<typename T> T* RALL<T>::operator->()const {         return _p; }         template<typename T> void RALL<T>::reset(T* new_p) {         delete _p;         _p = new_p; }         template<typename T> void RALL<T>::swap(RALL<T> &rhs) {         std::swap(_p,rhs._p); }

#include<iostream> #include"RALL.h" using namespace std; class resource {         public:                 resource(){cout<<"resource::resouce()"<<endl;}                 ~resource(){cout<<"resource::~resource()"<<endl;}         private: }; class test {         public:                 test():_p(new resource){ cout<<"test::test()"<<endl; }              ~test(){ cout<<"test::~test()"<<endl; }                 //拷贝构造函数                 //RALL类重载了*运算符，这里new的同时                 //直接用rhs的值来初始化新开辟的空间                 test(const test& rhs):_p(new resource(*rhs._p))                 { cout<<"test::test(const test&)"<<endl; } //                test& operator=(const test& rhs) //                { //                        cout<<"test::operator=(const test&)"<<endl; //                        if(this==&rhs){return *this;} //                        //delete this->_p.get(); //                        //*_p = *(rhs._p); //                        _p.reset((rhs._p).get());  // 函数里面已经写了释放 //                        return *this; //                }         private:                 test& operator=(const test& rhs);  // 赋值构造函数造成多个指针指向一块区域                 // dubble free         private:                 RALL<resource> _p; }; int main() {         test em;         cout<<"--------------------------"<<endl;         test em2;         cout<<"**************************"<<endl;         //em2 = em;  // 这里赋值了会导致em2和em释放，段错误         //后面我在RALL类里面的析构函数做了特殊处理，指针为NULL才delete //结果没考虑多个指针指向一块区域         cout<<"准备开始释放资源:"<<endl;         return 0; }

---

资源管理--智能指针：

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

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

      ——RAII类模拟智能指针

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

std::auto_ptr(复制/赋值)   现在已淘汰

std::unique_ptr  c++11

std::shared_ptr  c++11

std::weak_ptr    c++11

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

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

2、std::auto_ptr要求其对“裸”指针的完全占有性---->

      ——在拷贝构造或赋值操作时,会发生所有权的转移      //两次使用auto_ptr，第一次的会转移，转移了之后就失效了，其后不能使用，只能最终获得转移权的智能指针使用

3、本身存在缺陷

#include <iostream> #include <memory> using namespace std; int main() {         double * pd = new double(88.99);         auto_ptr<double> app(pd);         cout<<"*app = "<<*app<<endl;         cout<<"app.get()= "<<app.get()<<endl;         cout<<"pd       = "<<pd<<endl;         int * pi = new int(5);         auto_ptr<int> api(pi);         auto_ptr<int> api2(api);   //这里实际上是拷贝         //表达的是值语义，但是实现有缺陷，在底层已经发生了所有权的转移         cout<<"*api2 = "<<*api2<<endl;         cout<<"*api = "<<*api<<endl;  //段错误，api已经不能在使用了         return 0; }

---

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

     ——拥有它所指向的对象

     ——无法进行复制、赋值操作

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

     ——具有移动(std::move)语义(和前面的把左值改右值一样)，可做为容器元素

1.无法进行复制、赋值操作   std::unique_ptr<int> ap(new int(88 );   std::unique_ptr<int> one (ap) ; // 会出错   std::unique_ptr<int> two = one; //会出错 3.可做为容器元素   unique_ptr<int> sp(new int(88));   vector<unique_ptr<int> > vec;   vec.push_back(std::move(sp));   //vec.push_back( sp ); 这样不行,会报错的.   //cout<<*sp<<endl;但这个也同样出错,说明sp添加到容器中之后,它自身报废了.

2.可以进行移动构造和移动赋值操作  unique_ptr<int> GetVal( ){     unique_ptr<int> up(new int(88 );     return up;  }  unique_ptr<int> uPtr = GetVal();   //ok  实际上上面的的操作有点类似于如下操作  unique_ptr<int> up(new int(88 );  unique_ptr<int> uPtr2 = std::move(up) ; //这里是显式的所有权转移. 把up所指的内存转给uPtr2了,而up不再拥有该内存.

#include <iostream> #include <memory> #include <vector> using namespace std; unique_ptr<int> getValue() {         unique_ptr<int> upi(new int (88));         return upi;  //最后获得的是一个右值 } int main() { //unique_ptr无法进行复制或赋值,表达的是对象语义         unique_ptr<int> one(new int(1));         //无法进行复制、赋值操作 //        unique_ptr<int> two(one);   //错 //        unique_ptr<int> three=one; //错

//可以进行移动构造和移动赋值操作 // 调用的是移动构造函数         unique_ptr<int> tmp = getValue();         unique_ptr<int> up(new int(88));         unique_ptr<int> up2 = move(up);  //这里把显示的左值所有权转移，把up所指的内存转移给up2，而up不再拥有该内存 //    cout<<" *up = "<<*up<<endl;  //段错误，move之后不能再使用         //可做为容器元素        unique_ptr<int> sp(new int(33));        vector<unique_ptr<int> > vec;         vec.push_back(move(sp));     //必须转换成右值 //     cout<<*sp<<endl;      //段错误，在添加到容器的过程中转换成右值，自身不再拥有内存         return 0; }

---

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

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

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

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

     ——问题：循环引用（最终导致内存泄露）

#include<iostream> #include<memory> using namespace std; int main() {         shared_ptr<int> sp(new int(1));         cout<<"*sp="<<*sp<<"  sp.use_count="<<sp.use_count()<<endl;         shared_ptr<int> sp2 = sp;  // 赋值,只是引用计数增加1         cout<<"*sp="<<*sp<<"  sp.use_count="<<sp.use_count()<<endl;         cout<<"*sp2="<<*sp2<<"  sp2.use_count="<<sp2.use_count()<<endl; }

6、std::shared_ptr是强引用智能指针

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

#include <iostream> #include <memory> using namespace std; class Parent;    //前向声明 class Child {         public:                 Child()   {  cout<< "Child()" <<endl;  }                 ~Child()  {  cout<< "~Child()" <<endl; }                 shared_ptr<Parent> _parentPtr; }; class Parent {         public:                 Parent()  {  cout<< "Parent()" <<endl;  }                 ~Parent() {  cout<< "~Parent()" <<endl; }                 shared_ptr<Child> _childPtr; };

int main() {//问题是：循环引用，发生内存泄露         shared_ptr<Parent> parentPtr(new Parent);         shared_ptr<Child> childPtr(new Child);         cout<< "parent' use_count()= "<<parentPtr.use_count()<<endl;         cout<< "child' use_count()= "<<childPtr.use_count()<<endl;         parentPtr->_childPtr = childPtr;         childPtr->_parentPtr = parentPtr;         cout<< "parent' use_count()= "<<parentPtr.use_count()<<endl;         cout<< "child' use_count()= "<<childPtr.use_count()<<endl;         return 0; }

---

7、std::weak_ptr 是弱引用智能指针

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

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

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

shared_ptr的误用

class std::enable_shared_from_this

方法shared_from_this()

删除器

#include <iostream> #include <memory> using namespace std; class Parent;    //前向声明 class Child {         public:                 Child()   {  cout<< "Child()" <<endl;  }                 ~Child()  {  cout<< "~Child()" <<endl; }                 weak_ptr<Parent> _parentPtr;    //弱引用   }; class Parent {         public:                 Parent()  {  cout<< "Parent()" <<endl;  }                 ~Parent() {  cout<< "~Parent()" <<endl; }                 shared_ptr<Child> _childPtr;                 //weak_ptr<Child> _parentPtr;   }; int main() {//问题是：循环引用，发生内存泄露;使用weak_ptr能够打破循环引用         shared_ptr<Parent> parentPtr(new Parent);         shared_ptr<Child> childPtr(new Child);         cout<< "parent' use_count()= "<<parentPtr.use_count()<<endl;         cout<< "child' use_count()= "<<childPtr.use_count()<<endl;         parentPtr->_childPtr = childPtr;         childPtr->_parentPtr = parentPtr;         cout<< "parent' use_count()= "<<parentPtr.use_count()<<endl;         cout<< "child' use_count()= "<<childPtr.use_count()<<endl;         return 0; }

#include<iostream> #include<memory> using namespace std; class X {         public:                 X(){ cout<<"X()"<<endl; }                 ~X(){ cout<<"~X()"<<endl; }                 void fun(){ cout<<"X::fun()"<<endl; } }; int main() {         weak_ptr<X> wp;         {                 cout<<"wp use count="<<wp.use_count()<<endl;  // weak_ptr没有get成员                 cout<<endl;                 shared_ptr<X> sp(new X);                 cout<<"addr ap="<<sp.get()<<"  sp use count="<<sp.use_count()<<endl;                 cout<<endl;                 wp = sp;  // 并没有增加引用计数                 cout<<"addr ap="<<sp.get()<<"  sp use count="<<sp.use_count()<<endl;                 cout<<"wp use count="<<wp.use_count()<<endl;                 cout<<endl;                 shared_ptr<X> sp2 = wp.lock();  // 弱引用要提升为强引用才能访问托管对象                 cout<<"addr ap="<<sp.get()<<"  sp use count="<<sp.use_count()<<endl;                 cout<<"wp use count="<<wp.use_count()<<endl;                 cout<<"addr sp2="<<sp2.get()<<"  sp2 use count="<<sp2.use_count()<<endl;                 if(!sp2){  cout<<"object is destroyed!"<<endl;  }                 else                 { // 引用计数+1                         sp2->fun();                         cout<<"weak_ptr lock 成功"<<endl;                 }         }  // 离开作用域,sp、sp2被释放  weak_ptr知道自己托管的对象是否释放了

cout<<endl;         shared_ptr<X> sp3 = wp.lock();  // new X的对象已经释放了，提升失败         if(!sp3){  cout<<"object is destroyed!"<<endl;  }         else         {                  sp3->fun();                 cout<<"weak_ptr lock 成功"<<endl;         }         cout<<"wp use count="<<wp.use_count()<<endl;         cout<<"addr sp3="<<sp3.get()<<"  sp3 use count="<<sp3.use_count()<<endl;         return 0; }

8、shared_ptr的误用

     ——class std::enable_shared_from_this

     ——方法  shared_from_this()

     ——删除器

class A:public enable_share_from_this<A>

使用场合：当类A被share_ptr管理，且在类A的成员函数里需要把当前类对象作为参数传给其他函数时，就需要传递一个指向自身的share_ptr。

我们就使类A继承enable_share_from_this，然后通过其成员函数share_from_this()返回当指向自身的share_ptr。

以上有2个疑惑：

1.把当前类对象作为参数传给其他函数时，为什么要传递share_ptr呢？直接传递this指针不可以吗？

    一个裸指针传递给调用者，谁也不知道调用者会干什么？假如调用者delete了该对象，而share_ptr此时还指向该对象。

2.这样传递share_ptr可以吗？share_ptr<this>

    这样会造成2个非共享的share_ptr指向一个对象(拷贝)(一个指针被两个对象托管)，最后造成2次析构该对象。

#include<iostream> #include<memory> using namespace std; class point:public enable_shared_from_this<point> {         public:                 point(int x=0,int y=0):_x(x),_y(y)                 { cout<<"point(int,int)"<<endl; }                 ~point()  { cout<<"~point()"<<endl; } #if 0                 point* add(const point* rhs)                 {                         _x += rhs->_x;                         _y += rhs->_y;                         return this;                 } #endif                 shared_ptr<point> add(const point* rhs)                 {                         //在类内部进行托管                         _x += rhs->_x;                         _y += rhs->_y;                         //return shared_ptr<point>(this);  // 和point* add(cosnt point*)一个效果。                         return shared_from_this();                         //这个方法在enable_shared_from_this<class T>中                 }                 friend ostream& operator<<(ostream& ,const point&);         private:                 int _x;                 int _y; }; ostream& operator<<(ostream& os,const point& rhs) {         os<<"("<<rhs._x<<","<<rhs._y<<")"; }

void test1()//对shared_ptr误用 { //1、对shared_ptr的误用         point* p1 = new point(1,2);         shared_ptr<point> sp1(p1);         cout<<"sp1 use count="<<sp1.use_count()<<endl;         shared_ptr<point> sp2(p1);  //只有sp2 = sp1才会提升引用计数 //      shared_ptr<point> sp2(sp1);  //这样也会提升引用计数         //重复对一个对象托管,会导致多次调用析构函数         cout<<"sp1 use count="<<sp1.use_count()<<endl;         cout<<"sp2 use count="<<sp2.use_count()<<endl; } void test2() {         shared_ptr<point> p1(new point(1,2));         shared_ptr<point> p2(new point(3,4));         cout<<"p1 use count="<<p1.use_count()<<"  p2 use count="<<p2.use_count()<<endl;         p2.reset(p1.get());  // reset先释放p2，在把p1的值赋给p2         cout<<"addr p1="<<p1<<endl;         cout<<"addr p2="<<p2<<endl;         cout<<"p1 use count="<<p1.use_count()<<"  p2 use count="<<p2.use_count()<<endl; } void test3() {            shared_ptr<point> p1(new point(1,2));              shared_ptr<point> p2(new point(3,4));             //误用, p1和p3同时托管一个对象            shared_ptr<point> p3(p1->add(p2.get()));            cout<<"p1 use count="<<p1.use_count()<<endl;            cout<<"p2 use count="<<p2.use_count()<<endl;            cout<<"p3 use count="<<p3.use_count()<<endl;                  cout<<"p1="<<p1<<"  p2="<<p2<<"  p3="<<p3<<endl;    } int main() {         //test1();  // 这里test1()和test2()同时打开段错误，不知道为啥         cout<<"---------------"<<endl;         //test2();  // 和上面同样的原因，我猜测是前面开辟的堆内存没有释放，后面又要来delete,所以出现错误。         cout<<"---------------"<<endl;         test3();         return 0; }

//point(int,int) //sp1 use count=1 //sp1 use count=1 //sp2 use count=1 //~point() //~point() //--------------- //point(int,int) //point(int,int) //p1 use count=1  p2 use count=1 //~point() //addr p1=0x244e030 //addr p2=0x244e030 //p1 use count=1  p2 use count=1 //~point() //~point() //--------------- //point(int,int) //point(int,int) //p1 use count=1 //p2 use count=1 //p3 use count=1 //p1=0xbd5030  p2=0xbd5070  p3=0xbd5030 //~point() //~point() //~point() //采用返回shared_from_this() //--------------- //point(int,int) //point(int,int) //p1 use count=2 //p2 use count=1 //p3 use count=2 //p1=0xc2f030  p2=0xc2f070  p3=0xc2f030 //~point() //~point()

#include <iostream> #include <stdio.h> #include <memory> using namespace std; struct Fpcloser {         void operator()(FILE * fp)         {                 if(fp)                 {                         cout<<"release file pointer!"<<endl;                         fclose(fp);                 }         } }; void test0() {//自己指定删除器         unique_ptr<FILE,Fpcloser> up( fopen("test.txt","w+"),Fpcloser() );         fputs("hello,world\n",up.get());     //get()返回托管对象的指针 } void test1() {//指定删除器的方式         shared_ptr<FILE> sp(fopen("test.txt","r+"),Fpcloser());         char buff[1024];         fgets(buff,sizeof(buff),sp.get());         cout<<buff; }

int main() {         //test0();         test1();         return 0; }

资源管理

》原理：利用栈对象去管理资源；栈对象的特性是创建对象是自动调用构造函数，当其生命周期结束时，会自动调用析构函数

》RALL

》智能指针

   auto_ptr  (已被废弃)

   unique_ptr

   shared_ptr

   weak_ptr