智能指針auto_prt的使用（c++學習筆記）

 c++中如果要申請資源一般用到new，最後釋放資源delete，如果我們在delete之前就退出了函數呢，看下面的代碼：

#include <iostream> //#include <memory> using namespace std; void fun() { int *ptr = new int; if(ptr == 0) { delete ptr; return; } cout << "hello prt" << endl; delete ptr; } int main() { fun(); return 0; }

 

這樣我們就要多寫一個delete，如果if有很多分支或者別情況呢。甚至有時候我們忘了delete呢，他將導致內存泄露。如果使用智能指針auto_ptr就不會出現這種情況了。
下面我們來看一個例子：

#include <iostream> #include <memory>//auto_ptr 需要用到的頭文件 using namespace std; void fun(auto_ptr<int> ptr) { if (ptr.get() == NULL) { cout << "NULL" << endl; } else { cout << *ptr << endl; } } int main() { auto_ptr<int> ptr(new int); //auto_ptr<int> ptr = new int(11); //ERROR 注意智能指針不能使用這種賦值方式 *ptr = 44; fun(ptr); //cout << *ptr << endl; if (ptr.get() == NULL) { cout << "delete" << endl; } return 0; }

編譯後結果爲 44    delete
很明顯我們可以看到ptr被釋放掉了。
注意，智能指針有擁有權轉移的性質，ptr1給ptr2賦值後，ptr1就被delete掉了就不能再取他的值了。代碼如下：

#include <iostream> #include <memory> using namespace std; ostream& operator<< (ostream& otm , auto_ptr<int>& ptr) { if(ptr.get() == NULL) { otm << "NULL" << endl; } else { otm << *ptr << endl; } return otm; } int main() { auto_ptr<int> ptr1(new int(22)); auto_ptr<int> ptr2; cout << ptr1 << endl; cout << ptr2 << endl; ptr2 = ptr1; cout << ptr1 << endl; cout << ptr2 << endl; return 0; }

編譯後結果爲22  NULL  NULL  22
可以看到執行ptr2 = ptr1後ptr1指向了NULL。
如果我們不希望看到擁有權的改變那就要在聲明是加const。擁有權不可以改變但你可以取他的值來賦值，例如:*ptr1 = * prt2。

 

 

下面附一份《c++標準程序庫》中提供的auto_ptr的實現代碼，看了下，跟《c++程序設計語言》中的差不多，但跟具體，據說比標準庫的有一些改進。

/* The following code example is taken from the book * "The C++ Standard Library - A Tutorial and Reference" * by Nicolai M. Josuttis, Addison-Wesley, 1999 * * (C) Copyright Nicolai M. Josuttis 1999. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ /* class auto_ptr * - improved standard conforming implementation */ namespace std { // auxiliary type to enable copies and assignments (now global) template<class Y> struct auto_ptr_ref { Y* yp; auto_ptr_ref (Y* rhs) : yp(rhs) { } }; template<class T> class auto_ptr { private: T* ap; // refers to the actual owned object (if any) public: typedef T element_type; // constructor explicit auto_ptr (T* ptr = 0) throw() : ap(ptr) { } // copy constructors (with implicit conversion) // - note: nonconstant parameter auto_ptr (auto_ptr& rhs) throw() : ap(rhs.release()) { } template<class Y> auto_ptr (auto_ptr<Y>& rhs) throw() : ap(rhs.release()) { } // assignments (with implicit conversion) // - note: nonconstant parameter auto_ptr& operator= (auto_ptr& rhs) throw() { reset(rhs.release()); return *this; } template<class Y> auto_ptr& operator= (auto_ptr<Y>& rhs) throw() { reset(rhs.release()); return *this; } // destructor ~auto_ptr() throw() { delete ap; } // value access T* get() const throw() { return ap; } T& operator*() const throw() { return *ap; } T* operator->() const throw() { return ap; } // release ownership T* release() throw() { T* tmp(ap); ap = 0; return tmp; } // reset value void reset (T* ptr=0) throw() { if (ap != ptr) { delete ap; ap = ptr; } } /* special conversions with auxiliary type to enable copies and assignments */ auto_ptr(auto_ptr_ref<T> rhs) throw() : ap(rhs.yp) { } auto_ptr& operator= (auto_ptr_ref<T> rhs) throw() { // new reset(rhs.yp); return *this; } template<class Y> operator auto_ptr_ref<Y>() throw() { return auto_ptr_ref<Y>(release()); } template<class Y> operator auto_ptr<Y>() throw() { return auto_ptr<Y>(release()); } }; }