智能指针之 Auto

在介绍智能指针之前我们先看以下代码：

void FunTest() { int *p = new int[10]; FILE* pFile = fopen( "1.txt", "w" ); if (pFile == NULL) { return; } // DoSomethint(); if (p != NULL) { delete[] p; p = NULL; } }

在该代码中，我们注意了对指针的释放却忽略了对文件指针的关闭。C++中的动态内存需要用户自己来维护，动态开辟的空间，在出函数作用域或者程序正常退出前必须释放掉，否则会造成内存泄露，有时我们已经非常谨慎了，然防不胜防。

智能指针(RAII)的存在一开始就是为了解决资源分配即初始化，其解决方案是定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。

所以有了第一代Auto_Ptr

template<class T> class AutoPtr { public: AutoPtr(T* ptr = NULL) :_ptr(ptr) {} AutoPtr(AutoPtr<T>& s) :_ptr(s._ptr) { s._ptr = NULL; //经过赋值拷贝，原本的智能指针s中_ptr 已经指向空 } AutoPtr<T>& operator=(AutoPtr<T>& s) { if (this != &s) { if (_ptr) { delete _ptr; } _ptr = s._ptr; s._ptr = NULL; //经过赋值运算符后同样被置空 } return *this; } T* operator->()const { return _ptr; } T& operator*()const { return *_ptr; } ~AutoPtr() { if (_ptr) { delete _ptr; } } private: T* _ptr; }; void Funtest1(AutoPtr<char> p) {} void Funtest2(AutoPtr<char>& p) {} int main() { AutoPtr<char> p1(new char); AutoPtr<char> p2(p1); //AutoPtr<char> p4(p3); 出错，不能通过编译，原因在拷贝构造函数中更改了具有常性的 p3 //Funtest1(p2); 同理，以传值形式作为函数形参，也要经过拷贝构造函数形成临时变量p，同理赋值崩溃 Funtest2(p2); //以引用的方式传递没有问题 *p2 = '1'; return 0; }

由此可见一代Auto_Ptr的缺点都有以下几点： 1：在Auto_Ptr中经过资源转移后，p1不能再访问空间 2：以值传递的形式作为函数参数后，一旦调用函数，该智能指针在原函数中也不能访问空间 3：const对象不能构造同类型对象

针对第一代Auto_Ptr的问题，于是乎有了第二代Auto_Ptr的产生实际上我们是使用一个bool 类型的 数据成员来表明该智能指针是否具有被析构的能力

template<class T> class AutoPtr { public: AutoPtr(T* ptr = NULL) :_ptr(ptr) , type(false) { if (_ptr) type = true; } AutoPtr(const AutoPtr<T>& s) :_ptr(s._ptr) , type(s.type) { s.type = false; } //拷贝构造函数中，将s对象具有析构的能力 type赋给新对象，而s.type赋值为false，说明不具有析构能力 AutoPtr<T>& operator=(const AutoPtr<T>& s) { if (this != &s) { if (_ptr && type) { delete _ptr; } _ptr = s._ptr; type = s.type; s.type = false; } return *this; } T& operator*()const { return *_ptr; } //析构函数中，我们将 type 为true的智能指针进行析构，从而避开了对同一空间释放多次的问题 ~AutoPtr() { if (_ptr && type) { delete _ptr; _ptr = NULL; type = false; } } private: T* _ptr; mutable bool type; //在成员函数体内只改变了type的值，针对于const对象，我们加关键字mutable可以更改type的值 }; void Funtest1(AutoPtr<char> p) {} int main() { AutoPtr<char> p1(new char); void Funtest1(p1); AutoPtr<char> p2(p1); AutoPtr<char> p3(new char); AutoPtr<char> p4(p3); Funtest1(p1); p1 = p3; *p3 ='1'; return 0; }

经过验证，我们确定基于第一代的修改我们成功的引入了第二代,但是我们引入了一个野指针的问题，一旦对于野指针进行操作，很容易造成问题，

当我们用智能指针管理一个无名的智能指针对象时，编译器会自动优化，调用系统的构造函数，如果我们想调用我们自己写的构造函数，我们推导出智能指针的第三个版本

template<class T> class autoptrref { public: autoptrref(T* ptr = NULL) :_ptr(ptr) {} T* _ptr; }; template<class T> class autoptr { public: //构造函数 autoptr(T* ptr = NULL) :_ptr(ptr) {} //拷贝构造函数 autoptr(autoptr<T>& ap) :_ptr(ap._ptr) { ap._ptr = NULL;//拷贝完后将ap._ptr置NULL } //赋值运算符的重载 autoptr<int>& operator=(autoptr<T>& ap) { if (this != &ap) { if (_ptr != NULL) { delete _ptr; } _ptr = ap._ptr; ap._ptr = NULL;//赋值完后将ap._ptr置NULL } return *this; } //解决办法 //重载autoptrref() operator autoptrref<T>()//将autoptr<T>转化为autoptrref<T> { autoptrref<T> temp(_ptr); _ptr = NULL; return temp; } //再重载一个拷贝构造函数 autoptr(const autoptrref<T>& apr) :_ptr(apr._ptr) {} ~autoptr()//析构函数 { if (_ptr != NULL) { delete _ptr; } } //*的重载 T& operator*()const { return *_ptr; } //得到原生态指针 T* Get()const { return _ptr; } private: T* _ptr; }; void funtest() { autoptr<int> ap(autoptrref<int>(autoptr<int>(new int))); //用无名的智能指针拷贝构造智能指针ap,则不会调用我们编写好得拷贝构造函数，而是调用系统自动合成个的拷贝构造函数 } //原因是编译器的自动优化，解决办法：重新增加一个类autoptrref,将无名对象的类型转化为autoptrref int main() { funtest(); return 0; }