资源管理
所谓资源就是，一旦使用了它，将来必须归还给系统！C++最常见的资源就是动态分配内存，如果不归还就会内存泄露。
1. 以对象管理资源
我们通常希望有一个对象来帮助我们解决资源管理的问题（自动调用析构函数），于是此章我们讨论auto_ptr和shared_ptr。
问题产生
假设我们希望使用一个工厂方法如：
class investment {...}; // 代表一个root class
investment* creatinvestment() { // 返回一个指针指向继承体系内动态分配的对象。
...
}
void f() {
investment* pInv = createinvestment();
...
delete pInv;
}
乍看起来这个函数并没有什么问题，正常的动态分配了对象，同时也删除了该对象。但问题在于…中可能出现异常情况，例如，提前的return，异常抛出，某个循环的continue等等，使得控制流无法读到delete语句，如此便出现了内存泄露。所以“单纯地以来f总是会执行其delete语句”是行不通的。
解决问题
为了解决这个问题，我们希望能把资源放入对象中，使得对象在离开其作用域时自动调用析构函数。于是，我们使用了auto_ptr。
void f() {
std::auto_ptr
pInv(createinvestment()); ... } // 经由auto_ptr的析构函数自动删除pInv。
这个简单的例子示范了“以对象管理资源”的两个关键想法：
* 获得资源后立刻放进管理对象内。此观念常被称为“资源取得时机便是初始化时机”（RAII准则)，因为我们几乎总是在取得一笔资源后同一语句内以它初始化某个对象。
* 管理对象运用析构函数确保资源被释放。不管控制流如何离开作用域，一旦对象被销毁，其析构函数自然会被自动调用，于是资源被释放。
然而，使用auto_ptr也需要注意，一定不能让多个auto_ptr指向同一个对象！因为每一个auto_ptr都会使用析构函数，他并不像智能指针一样会管理有多少指针指向同一对象。并且与copy相关的操作都会使原来的指针指向null，如此使对象只有一个auto_ptr指向。
基于auto_ptr的特性，我们便不能子啊STL容器中使用auto_ptr。auto_ptr
void f() {
std::shared_ptr
pInv(createinvestment()); ... } // 经由shared_ptr的析构函数自动删除pInv。
几乎和auto_ptr一样，但是相应的复制行为会正常了许多。
补充auto_ptr相关知识
C++的auto_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。
使用std::auto_ptr，要#include 。
以下是源码:
template
class auto_ptr { private: T*ap; public: //constructor & destructor-----------------------------------(1) explicit auto_ptr(T*ptr=0)throw():ap(ptr) { } ~auto_ptr()throw() { delete ap; } //Copy & assignment--------------------------------------------(2) auto_ptr(auto_ptr& rhs)throw():ap(rhs.release()) { } template
auto_ptr(auto_ptr
&rhs)throw():ap(rhs.release()) { } auto_ptr& operator=(auto_ptr&rhs)throw() { reset(rhs.release()); return *this; } template
auto_ptr& operator=(auto_ptr
&rhs)throw() { reset(rhs.release()); return *this; } //Dereference----------------------------------------------------(3) T& operator*()const throw() { return *ap; } T* operator->()const throw() { return ap; } //Helper functions------------------------------------------------(4) //value access T* get()const throw() { return ap; } //release owner ship 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-----------------------------------------------(5) template
struct auto_ptr_ref { Y*yp; auto_ptr_ref(Y*rhs):yp(rhs){} }; auto_ptr(auto_ptr_ref
rhs)throw():ap(rhs.yp) { } auto_ptr& operator=(auto_ptr_ref
rhs)throw() { reset(rhs.yp); return*this; } template
operator auto_ptr_ref
()throw() { return auto_ptr_ref
(release()); } template
operator auto_ptr
()throw() { return auto_ptr
(release()); } };
shared_ptr
详情见：shared_ptr
在资源管理类中小心copying行为
前面我们提到了RAII观念，并以此作为“资源管理类”的记住，也描述了auto_ptr和shared_ptr如何将这个观念表现在heap-based资源上。然而并非所有资源都是heap-based，对那种资源而言，我们就需要建立自己的资源管理类。(栈，由编译器自动管理，无需程序员手工控制；堆：产生和释放由程序员控制。)
问题产生
我们处理类型为Mutex的互斥器对象，同时使用一个class来管理它。
void lock(Mutex* pm);
void unlock(Mutex* pm);
class Lock {
public:
explicit Lock(Mutex* pm) : mutexPtr(pm) {
lock(mutexPtr);
}
~Lock() { unlock(mutexPtr); }
private:
Mutex *mutexPtr;
};
main () {
Mutex m;
...
{
Lock m1(&m);
...
Lock m11(&m);
Lock m