C++中指针申请和释放内存通常采用的方式是new和delete。然而标准C++中还有一个强大的模版类就是auto_ptr，它可以在你不用的时候自动帮你释放内存。下面简单说一下用法。
用法一：
std::auto_ptr m_example(newMyClass());
用法二：
std::auto_ptr m_example;
m_example.reset(newMyClass());
用法三（指针的赋值操作）：
std::auto_ptr m_example1(newMyClass());
std::auto_ptr m_example2(newMyClass());
m_example2=m_example1;
则C++会把m_example所指向的内存回收，使m_example1的值为NULL，所以在C++中，应绝对避免把auto_ptr放到容器中，因为容器中难免出现赋值操作，会导致指针被赋值为NULL；
auto_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。这里是一个简单的代码示例，没有使用auto_ptr所以不安全：
// 示例1(a)：原始代码
void f()
{
T* pt( new T );
/*...更多的代码...*/
delete pt;
}
// 示例1(b)：安全代码，使用了auto_ptr
void f()
{
auto_ptr pt(newT );
/*...更多的代码...*/
}// 酷：当pt出了作用域时析构函数被调用，从而对象被自动删除
现在代码不会泄漏T类型的对象，不管这个函数是正常退出还是抛出了异常，因为pt的析构函数总是会在出栈时被调用，清理会自动进行。
最后，使用一个auto_ptr就像使用一个内建的指针一样容易，而且如果想要“撤销”资源，重新采用手动的所有权，我们只要调用release()。
// 示例2：使用一个auto_ptr
void g()
{
// 现在，我们有了一个分配好的对象
T* pt1 =new T;
// 将所有权传给了一个auto_ptr对象
auto_ptr pt2(pt1);
// 使用auto_ptr就像我们以前使用简单指针一样，
*pt2 = 12;// 就像*pt1 = 12
pt2->SomeFunc();// 就像pt1->SomeFunc();
// 用get()来获得指针的值
assert( pt1 == pt2.get() );
// 用release()来撤销所有权
T* pt3 = pt2.release();
// 自己删除这个对象，因为现在没有任何auto_ptr拥有这个对象
delete pt3;
}// pt2不再拥有任何指针，所以不要试图删除它...OK，不要重复删除
最后，我们可以使用auto_ptr的reset()函数来重置auto_ptr使之拥有另一个对象。如果这个auto_ptr已经拥有了一个对象，那么，它会先删除已经拥有的对象，因此调用reset()就如同销毁这个auto_ptr，然后新建一个并拥有一个新对象：
// 示例 3：使用reset()
voidh()
{
auto_ptr pt(newT(1) );
pt.reset(newT(2) );// 删除由"new T(1)"分配出来的第一个T
}// 最后pt出了作用域，第二个T也被删除了
auto_ptr用法：
1.需要包含头文件。1.需要包含头文件。
2. Constructor：explicit auto_ptr(X* p = 0) throw();将指针p交给auto_ptr对象托管。
3. Copy constructor：auto_ptr(const auto_ptr&) throw(); template auto_ptr(const auto_ptr& a) throw();指针的托管权会发生转移。
4. Destructor: ~auto_ptr();释放指针p指向的空间。
5.提供了两个成员函数X* get() const throw();//返回保存的指针
6.对象中仍保留指针X* release() const throw();//返回保存的指针，对象中不保留指针
auto_ptr实现关键点：
1.利用特点“栈上对象在离开作用范围时会自动析构”。
2.对于动态分配的内存，其作用范围是程序员手动控制的，这给程序员带来了方便但也不可避免疏忽造成的内存泄漏，毕竟只有编译器是最可靠的。
3. auto_ptr通过在栈上构建一个对象a，对象a中wrap了动态分配内存的指针p，所有对指针p的操作都转为对对象a的操作。而在a的析构函数中会自动释放p的空间，而该析构函数是编译器自动调用的，无需程序员操心。
多说无益，看一个最实用的例子：
[cpp]view plaincopy
#include
#include
usingnamespacestd;
classTC
{
public:
TC(){cout<<"TC()"<
~TC(){cout<<"~TC()"<
};
voidfoo(boolisThrow)
{
auto_ptr pTC(newTC);// 方法2
//TC *pTC = new TC; // 方法1
try
{
if(isThrow)
throw"haha";
}
catch(constchar* e)
{
//delete pTC; // 方法1
throw;
}
//delete pTC; // 方法1
}
intmain()
{
try
{
foo(true);
}
catch(...)
{
cout<<"caught"<
}
system("pause");
}
1.如果采用方案1，那么必须考虑到函数在因throw异常的时候释放所分配的内存，这样造成的结果是在每个分支处都要很小心的手动delete pTC;。
2.如果采用方案2，那就无需操心何时释放内存，不管foo()因何原因退出，栈上对象pTC的析构函数都将调用，因此托管在之中的指针所指的内存必然安全释放。
至此，智能指针的优点已经很明了了。
但是要注意使用中的一个陷阱，那就是指针的托管权是会转移的。例如在上例中，如果auto_ptr pTC(new TC); auto_ptr pTC1=pTC;那么，pTC1将拥有该指针，而pTC没有了，如果再用pTC去引用，必然导致内存错误。
要避免这个问题，可以考虑使用采用了引用计数的智能指针，例如boost::shared_ptr等。auto_ptr不会降低程序的效率，但auto_ptr不适用于数组，auto_ptr根本不可以大规模使用。shared_ptr也要配合weaked_ptr，否则会很容易触发循环引用而永远无法回收内存。理论上，合理使用容器加智能指针，C++可以完全避免内存泄露，效率只有微不足道的下降（中型以上程序最多百分之一）。