[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技术。