【C++箴言:使用对象管理资源】

假设我们和一个投资（例如，股票，债券等）模型库一起工作，各种各样的投资形式从一个根类 Investment 派生出来：
　　
　　class Investment { ... }; // root class of hierarchy of
　　// investment types
　　进一步假设这个库使用了通过一个 factory 函数为我们提供特定 Investment 对象的方法：
　　
　　Investment* createInvestment(); // return ptr to dynamically allocated
　　// object in the Investment hierarchy;
　　// the caller must delete it
　　// (parameters omitted for simplicity)
　　通过注释指出，当 createInvestment 函数返回的对象不再使用时，由 createInvestment 的调用者负责删除它。那么，请考虑，写一个函数 f 来履行以下职责：
　　
　　void f()
　　{
　　Investment *pInv = createInvestment(); // call factory function
　　... // use pInv
　　delete pInv; // release object
　　}
　　这个看上去没问题，但是有几种情形会造成 f 在删除它从 createInvestment 得到的 investment 对象时失败。有可能在这个函数的 "..." 部分的某处有一个提前出现的 return 语句。假如这样一个 return 执行了，控制流程就再也无法到达 delete 语句。还可能发生的一个类似情况是假如 createInvestment 的使用和删除在一个循环里，而这个循环以一个 continue 或 goto 语句提前退出。还有，"..." 中的一些语句可能抛出一个异常。假如这样，控制流程不会再到达那个 delete。无论那个 delete 被如何跳过，我们泄漏的不仅仅是容纳 investment 对象的内存，还包括那个对象持有的任何资源。
　　
　　当然，小心谨慎地编程能防止这各种错误，但考虑到这些代码可能会随着时间的流逝而发生变化。为了对软件进行维护，一些人可能会在没有完全把握对这个函数的资源治理策略的其它部分的影响的情况下增加一个 return 或 continue 语句。尤有甚者，f 的 "..." 部分可能调用了一个从不惯于抛出异常的函数，但是在它被“改良”后忽然这样做了。依靠于 f 总能到达它的 delete 语句根本靠不住。
　　
　　为了确保 createInvestment 返回的资源总能被释放，我们需要将那些资源放入一个类中，这个类的析构函数在控制流程离开 f 的时候会自动释放资源。实际上，这只是本文介绍的观念的一半：将资源放到一个对象的内部，我们可以依靠 C++ 的自动地调用析构函数来确保资源被释放。（过一会儿我们还要介绍本文观念的另一半。）
　　
　　许多资源都是动态分配到堆上的，并在一个单独的块或函数内使用，而且应该在控制流程离开那个块或函数的时候释放。标准库的 auto_ptr 正是为这种情形量体裁衣的。auto_ptr 是一个类似指针的对象（一个智能指针），它的析构函数自动在它指向的东西上调用 delete。下面就是如何使用 auto_ptr 来预防 f 的潜在的资源泄漏：
　　
　　void f()
　　{
　　std::auto_ptr<Investment> pInv(createInvestment()); // call factory
　　// function
　　... // use pInv as
　　// before
　　} // automatically
　　// delete pInv via
　　// auto_ptr’s dtor
　　这个简单的例子示范了使用对象治理资源的两个重要的方面：
　　
　　获得资源后应该立即移交给资源治理对象。如上，createInvestment 返回的资源被用来初始化即将用来治理它的 auto_ptr。实际上，因为获取一个资源并在同一个语句中初始化资源治理对象是如此常见，所以使用对象治理资源的观念也经常被称为 Resource Acquisition Is Initialization (RAII)。有时被获取的资源是被赋值给资源治理对象的，而不是初始化它们，但这两种方法都是在获取资源的同时就立即将它移交给资源治理对象。
　　
　　资源治理对象使用它们的析构函数确保资源被释放。因为当一个对象被销毁时（例如，当一个对象离开其活动范围）会自动调用析构函数，无论控制流程是怎样离开一个块的，资源都会被正确释放。假如释放资源的动作会引起异常抛出，事情就会变得棘手，不过，关于那些问题以后我将专题讲解，所以不必担心它。
　　
　　因为当一个 auto_ptr 被销毁的时候，会自动删除它所指向的东西，所以不要让超过一个的 auto_ptr 指向同一个对象非常重要。假如发生了这种事情，那个对象就会被删除超过一次，而且会让你的程序通过捷径进入未定义行为。为了防止这个问题，auto_ptrs 具有不同平常的特性：拷贝它们（通过拷贝构造函数或者拷贝赋值运算符）就是将它们置为空，拷贝的指针被设想为资源的唯一所有权。
　　
　　std::auto_ptr<Investment> // pInv1 points to the
　　pInv1(createInvestment()); // object returned from
　　// createInvestment
　　
　　std::auto_ptr<Investment> pInv2(pInv1); // pInv2 now points to the
　　// object; pInv1 is now null
　　
　　pInv1 = pInv2; // now pInv1 points to the
　　// object, and pInv2 is null
　　这个希奇的拷贝行为，增加了潜在的需求，就是通过 auto_ptrs 治理的资源必须绝对没有超过一个 auto_ptr 指向它们，这也就意味着 auto_ptrs 不是治理所有动态分配资源的最好方法。例如，STL 容器要求其内含物能表现出“正常的”拷贝行为，所以 auto_ptrs 的容器是不被答应的。
　　
　　相对于 auto_ptrs，另一个可选方案是一个引用计数智能指针（reference-counting smart pointer, RCSP）。一个 RCSP 是一个智能指针，它能持续跟踪有多少对象指向一个特定的资源，并能够在不再有任何东西指向那个资源的时候删除它。就这一点而论，RCSP 提供的行为类似于垃圾收集（garbage collection）。与垃圾收集不同的是，无论如何，RCSP 不能打破循环引用（例如，两个没有其它使用者的对象互相指向对方）。
　　
　　TR1 的 tr1::shared_ptr是一个 RCSP，所以你可以这样写 f：
　　
　　void f()
　　{
　　...
　　
　　std::tr1::shared_ptr<Investment>
　　pInv(createInvestment()); // call factory function
　　... // use pInv as before
　　} // automatically delete
　　// pInv via shared_ptr’s dtor
　　这里的代码看上去和使用 auto_ptr 的几乎相同，但是拷贝 shared_ptrs 的行为却自然得多：
　　
　　void f()
　　{
　　...
　　
　　std::tr1::shared_ptr<Investment> // pInv1 points to the
　　pInv1(createInvestment()); // object returned from
　　// createInvestment
　　
　　std::tr1::shared_ptr<Investment> // both
　　pInv1 and pInv2 now
　　pInv2(pInv1); // point to the object
　　
　　pInv1 = pInv2; // ditto - nothing has
　　// changed
　　...
　　} // pInv1 and pInv2 are
　　// destroyed, and the
　　// object they point to is
　　// automatically deleted
　　因为拷贝 tr1::shared_ptrs 的工作“符合预期”，它们能被用于 STL 容器以及其它和 auto_ptr 的非正统的拷贝行为不相容的环境中。
　　
　　不要搞错，本文不是关于 about auto_ptr，tr1::shared_ptr 或任何其它种类的智能指针。而是关于使用对象治理资源的重要性的。about auto_ptr 和 tr1::shared_ptr 仅仅是做这些事的对象的例子。（关于 tr1::shared_ptr 的更多信息，请参考 Item 14，18 和 54。）
　　
　　about auto_ptr 和 tr1::shared_ptr 都在它们的析构函数中使用 delete，而不是 delete []。这就意味着将 about auto_ptr 或 tr1::shared_ptr 用于动态分配的数组是个馊主意，可是，可悲的是，那居然可以编译：
　　
　　std::auto_ptr<std::string> // bad idea! the wrong
　　aps(new std::string[10]); // delete form will be used
　　
　　std::tr1::shared_ptr<int> spi(new int[1024]); // same problem
　　你可能会吃惊地发现 C++ 中没有可用于动态分配数组的类似 auto_ptr 或 tr1::shared_ptr 这样的东西，甚至在 TR1 中也没有。那是因为 vector 和 string 几乎总是能代替动态分配数组。假如你依然觉得有可用于数组的类似 auto_ptr 和类似 tr1::shared_ptr 的类更好一些的话，可以去看看 Boost。在那里，你将兴奋地找到 boost::scoped_array 和 boost::shared_array 两个类提供你在寻找的行为。 本 Item 的关于使用对象治理资源的指导间接表明：假如你手动释放资源（例如，使用 delete，而不使用资源治理类），你就是在自找麻烦。像 auto_ptr 和 tr1::shared_ptr 这样的预制的资源治理类通常会使本文的建议变得轻易，但有时，你使用了一个资源，而这些预加工的类不能如你所愿地做事。假如碰上这种情况，你就需要精心打造你自己的资源治理类。那也并非困难得可怕，但它包含一些需要你细心考虑的微妙之处。
　　
　　作为最后的意见，我必须指出 createInvestment 的未加工指针的返回形式就是资源泄漏的请帖，因为调用者忘记在他们取回来的指针上调用 delete 实在是太轻易了。（即使他们使用一个 auto_ptr 或 tr1::shared_ptr 来完成 delete，他们仍然必须记住将 createInvestment 的返回值存储到智能指针对象中。）对付这个问题需要改变 createInvestment 的接口。
　　
　　Things to Remember
　　
　　·为了防止资源泄漏，使用 RAII 对象，在 RAII 对象的构造函数中获得资源并在析构函数中释放它们。
　　
　　·两个通用的 RAII 是 tr1::shared_ptr 和 auto_ptr。tr1::shared_ptr 通常是更好的选择，因为它的拷贝时的行为是符合直觉的。拷贝一个 auto_ptr 是将它置为空。