源起：

C++编程中，最容易出的问题之一，就是内存泄露，而new一个对象，却忘了delete它，则是造成内存泄露的主要原因之一

例子一：

void foo()
{XXXObject* xo = new XXXObject;if(!xo->DoSomething())//do something出错了return；//返回（可是，糟糕，忘了delete xo呢）try{xo->DoAnotherThing();}catch(...)//出异常了...{return false; //又忘了delete xo了。}delete xo;return;
}

函数最后是释放xo,可是在DoSomething和DoAnotherThing不成功后，忘了释放xo,直接return了。

例子二：

XXXObject* CreateXXXFromFile(char const* filename)
{std::ifstream ifs(filename);int i;std::string s;ifs >> i;std::getline(ifs, s);XXXObject* xo = new XXXObject(i, s);xo->init();return xo;
}

C++编程箴言之一：“谁创建，谁释放”。

“CreateXXX”这类函数，经常被称为“工厂函数”。在特定的业务逻辑下，创建一个对象，需要像车间流水线一样先准备一些零件（例中的i和s），最后再调用构造函数产生一个对象。

问题出在使用者身上：

void foo()
{XXXObject* xo = CreateXXXFromFile("d:\\material\1.dat");xo->DoSomething();return;
}

更有甚者：

void foo()
{/*调用者根本没有处理CreateXXXFromFile()返回的指针，放任它占用内存不释放,(当然，这样使用函数，通常逻辑上也有错误)*/CreateXXXFromFile("d:\\material\\1.dat");
}

作为CreateXXXFromFile的作者，有没有办法既能够方式一个new出来的对象，又能够在调用者忘记释放它的返回值（哪怕是干脆没有提供变量用以“hold”住返回值）时，自动干掉函数内部创建的那个对象呢？我们已经知道，可以使用shared_ptr<T>，但如果假装不知道呢？

基本解决思路

C++的两个特性：

一是内存占用至少分成两种：栈内存和堆内存，堆内存需要手工释放，栈内存却能在其作用域结构之后，自动释放；

二是C++对象会在释放时，调用析构函数。

结合这连个特性，可以将“堆”内存（new出来的内存是堆内存的一种）在生命周期管理行为，模拟成“栈”内存方式。

先看第一个版本，用作原理演示：

struct AutoPtr
{AutoPtr(){this->_ptr = new int;}~AutoPtr(){cout << "调用析构，删除指针" << endl;delete this->_ptr;}int* _ptr;
};

AutoPtr在构造时，创建一个整数指针，在析构时，删除它。这一原理，它已经可以投入使用，做个对比：

原始版本（裸指针）	AutoPtr版本一
void foo_1() {     cout << "foo_1使用裸指针" << endl;     int * ptr = new int;     * ptr = 100;     cout << * ptr << endl;     delete ptr; //手工释放 }	void foo_2() {     cout << "foo_2使用AutoPtr" << endl;     AutoPtr ap;     *(ap._ptr) = 100;     cout << *(ap._ptr) << endl; }

原始版本

AutoPtr版本一

foo_2函数一结束，栈变量ap就会自动释放，释放是调用析构，析构函数负责释放_ptr。

AutoPtr的第一个缺陷：

它固定只用于int指针。这问题好解决，上模板呀：

template <typename T>
struct AutoPtr
{AutoPtr(){this->_ptr = new T;}~AutoPtr(){delete this->_ptr;}T* _ptr;
};

课堂作业：AutoPtr模板版本应用

67行，sap死亡时，调用析构函数，会删除_ptr一次

88行，又删除_ptr一次，所以内存释放两次