[Chrome源码阅读] 理解Chrome的smart pointer

Chrome代码中大量运用了智能指针来管理对象的指针，解决对象生命期的问题。这篇文章尝试着理解Chrome中定义的几个智能指针类。

1. scoped_ptr/scoped_array/scopred_array_malloc

以scopred开头的智能指针类定义在/src/base/scoped_ptr.h文件中。它们有着很明确的设计目标，对new/new[]/malloc出来的对象指针进行简单的包装，来管理对象的内存分配和释放。比如scoped_ptr类对new/delete进行了简单的包装，提供类似于std::auto_ptr类似的接口，但是却摒弃std::auto_ptr设计中令人诟病的拷贝复制时被管理的对象转移的问题。简单的禁用拷贝和复制函数就可以达到此效果。所以它们的使用场合就非常明确和简单有限：

 //   {
 //     scoped_ptr<Foo> foo;          // No pointer managed.
 //     foo.reset(new Foo("wee"));    // Now a pointer is managed.
 //     foo.reset(new Foo("wee2"));   // Foo("wee") was destroyed.
 //     foo.reset(new Foo("wee3"));   // Foo("wee2") was destroyed.
 //     foo->Method();                // Foo::Method() called.
 //     foo.get()->Method();          // Foo::Method() called.
 //     SomeFunc(foo.Release());      // SomeFunc takes owernship, foo no longer
 //                                   // manages a pointer.
 //     foo.reset(new Foo("wee4"));   // foo manages a pointer again.
 //     foo.reset();                  // Foo("wee4") destroyed, foo no longer
 //                                   // manages a pointer.
 //   }  // foo wasn't managing a pointer, so nothing was destroyed.

同时它们也禁止了两个智能指针之间的比,较，因为它们都不允许一个对象同时被2个智能指针同时管理：

 private：
   // Forbid comparison of scoped_ptr types.  If C2 != C, it totally doesn't
   // make sense, and if C2 == C, it still doesn't make sense because you should
   // never have the same object owned by two different scoped_ptrs.
   template <class C2> bool operator==(scoped_ptr<C2> const& p2) const;
   template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const;

有一点需要注意的是，类中的很多函数用了编译器的检查机制：

 ~scoped_ptr() {
   enum { type_must_be_complete = sizeof(C) };
   delete ptr_;
 }

所以，编译这些模板类时，必须知道管理对象的定义。也就是说被管理对象的定义须在这些模板类定义之前给出。

2. scoped_refptr/RefCounted<T>/RefCountedThreadSafe<T>

除了上面介绍的简单的智能指针之外，还有一个广泛使用的智能指针是针对智能指针的，类似于boost::shared_ptr类，它就是scoped_refptr。它管理的对象需继承于模板类RefCounted<T>，T就是自己本身。RefCounted<T>模板了提供了AddRef和Release函数(yy一下，为什么不叫IncRef和DecRef，意义不更明确吗？)，同时还维护一个INT类型的引用计数。RefCountedThreadSafe<T>是线程安全的RefCounted版本，原因在于引用计数不是采用INT类型，而是一个AtomicRefCount类型(原子的)。

我们重点来关注下scoped_refptr模板类:

 template <class T>
 class scoped_refptr {
  public:
   scoped_refptr() : ptr_(NULL) {
   }

   scoped_refptr(T* p) : ptr_(p) {
     if (ptr_)
       ptr_->AddRef();
   }

   scoped_refptr(const scoped_refptr<T>& r) : ptr_(r.ptr_) {
     if (ptr_)
       ptr_->AddRef();
   }

   ~scoped_refptr() {
     if (ptr_)
       ptr_->Release();
   }

   T* get() const { return ptr_; }
   operator T*() const { return ptr_; }
   T* operator->() const { return ptr_; }

   scoped_refptr<T>& operator=(T* p) {
     // AddRef first so that self assignment should work
     if (p)
       p->AddRef();
     if (ptr_ )
       ptr_ ->Release();
     ptr_ = p;
     return *this;
   }

   scoped_refptr<T>& operator=(const scoped_refptr<T>& r) {
     return *this = r.ptr_;
   }

   void swap(T** pp) {
     T* p = ptr_;
     ptr_ = *pp;
     *pp = p;
   }

   void swap(scoped_refptr<T>& r) {
     swap(&r.ptr_);
   }

  protected:
   T* ptr_;
 };

scoped_refptr和boost::shared_ptr之间的区别：

boost::shared_ptr自己管理引用计数，每当它的拷贝构造和赋值运算符被调用时，这个引用计数加1。而scoped_refptr不管理引用计数，由对象自己管理。这样就带来下面不同的用法：

boost::shared_ptr的用例(不正确的):

 int* pa = new int(3);
 {
     boost::shared_ptr<int> psa(pa);
     ...
     boost::shared_ptr<int> psb(pa);
 }

psa/psb被销毁时都会尝试删除pa，结果导致double-delete问题出现。

如果换成scoped_ptr，那么就不会出现上述的问题。

关于智能指针的拥有权策略技术，共有deep copy, reference counting, reference linking和destructive copy。<Modern C++ Design>书籍第7章第5节详细讲到了这几种技术的优缺点，而且Loki库也提供这几种策略技术的实作版本。Chrome里面的智能指针和boost::shared_ptr都是采用reference counting技术。