chromium之scoped_ptr

看看怎么使用

// Scopers help you manage ownership of a pointer, helping you easily manage the

// a pointer within a scope, and automatically destroying the pointer at the

// end of a scope.  There are two main classes you will use, which coorespond

// to the operators new/delete and new[]/delete[].

//

// Example usage (scoped_ptr):

//   {

//     scoped_ptr<Foo> foo(new Foo("wee"));

//   }  // foo goes out of scope, releasing the pointer with it.

//

//   {

//     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.

//

// Example usage (scoped_array):

//   {

//     scoped_array<Foo> foo(new Foo[100]);

//     foo.get()->Method();  // Foo::Method on the 0th element.

//     foo[10].Method();     // Foo::Method on the 10th element.

//   }

scoped_ptr顾名思义，就是离开作用域，就会自动析构。

---

这跟上一节的chromium之ref_counted什么区别。

class MyFoo : public base::RefCounted<MyFoo> {

};

MyFoo *foo = new MyFoo;

foo->AddRef();

foo->AddRef();

foo->Release(); 

foo->Release(); 

// foo has been delete

区别在于RefCounted必须调用Release才会自动析构，而且可以有多次引用，而scoped_ptr离开作用域就会自动析构

---

// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>

// automatically deletes the pointer it holds (if any).

// That is, scoped_ptr<T> owns the T object that it points to.

// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.

// Also like T*, scoped_ptr<T> is thread-compatible, and once you

// dereference it, you get the threadsafety guarantees of T.

//

// The size of a scoped_ptr is small:

// sizeof(scoped_ptr<C>) == sizeof(C*)

template <class C>

class scoped_ptr {

 public:

  // The element type

  typedef C element_type;

  // Constructor.  Defaults to intializing with NULL.

  // There is no way to create an uninitialized scoped_ptr.

  // The input parameter must be allocated with new.

  explicit scoped_ptr(C* p = NULL) : ptr_(p) { }

  // Destructor.  If there is a C object, delete it.

  // We don't need to test ptr_ == NULL because C++ does that for us.

  ~scoped_ptr() {

    enum { type_must_be_complete = sizeof(C) };

    delete ptr_;

  }

  // Reset.  Deletes the current owned object, if any.

  // Then takes ownership of a new object, if given.

  // this->reset(this->get()) works.

  void reset(C* p = NULL) {

    if (p != ptr_) {

      enum { type_must_be_complete = sizeof(C) };

      delete ptr_;

      ptr_ = p;

    }

  }

  // Accessors to get the owned object.

  // operator* and operator-> will assert() if there is no current object.

  C& operator*() const {

    assert(ptr_ != NULL);

    return *ptr_;

  }

  C* operator->() const  {

    assert(ptr_ != NULL);

    return ptr_;

  }

  C* get() const { return ptr_; }

  // Comparison operators.

  // These return whether two scoped_ptr refer to the same object, not just to

  // two different but equal objects.

  bool operator==(C* p) const { return ptr_ == p; }

  bool operator!=(C* p) const { return ptr_ != p; }

  // Swap two scoped pointers.

  void swap(scoped_ptr& p2) {

    C* tmp = ptr_;

    ptr_ = p2.ptr_;

    p2.ptr_ = tmp;

  }

  // Release a pointer.

  // The return value is the current pointer held by this object.

  // If this object holds a NULL pointer, the return value is NULL.

  // After this operation, this object will hold a NULL pointer,

  // and will not own the object any more.

  C* release() {

    C* retVal = ptr_;

    ptr_ = NULL;

    return retVal;

  }

 private:

  C* ptr_;

  // 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;

  // Disallow evil constructors

  scoped_ptr(const scoped_ptr&);

  void operator=(const scoped_ptr&);

};

这里有一个方法release()，可以释放指针

Foo *ptr = nullptr;

{

    scoped_ptr<Foo> foo(new Foo);

    ptr = foo.release(); // ptr get obj;

}

assert(ptr != nullptr);