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; } <img src="data:image/png;base64,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" />

/** **利用一个对象在离开个域中会调用析构函数的特性， **在构造函数中完成初始化，在析构函数中完成清理工作，将需要 **操作和保护的指针作为成员变量放入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; //错 <img src="data:image/png;base64,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" />

//可以进行移动构造和移动赋值操作 // 调用的是移动构造函数 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是强引用智能指针强引用，只要有一个引用存在，对象就不能被释放

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

个人收藏笔记记录

开通VIP