概述
-
在广义上，智能指针划分为两类。
-
第一类智能指针引用的对象是可以共享的，也就是一个对象可以同时被多个智能指针引用。
这类智能指针要求被引用的对象具有计数的功能，数值的大小就表示它目前被多少个智能指针引用。当一个对象的引用计数值等于0的时候，就表示它要被释放了。
这类智能指针适合作为函数参数或者返回值在模块之间进行传递，从而实现共享。 -
第二类智能指针引用的对象是独占的，也就是一个对象同一时刻只可以被一个智能指针引用。这类智能指针不要求被引用对象具有计数的功能。
只要这类智能指针的生命周期超出了它自己的范围，那么它引用的对象就会被自动销毁。
这类智能指针适合在函数或者内部使用，用来自动化释放那些不需要了的对象。
第一类：scoped_refptr
- 由于它要求被引用对象具有计数功能，因此就提供了一个具有计数功能的基类RefCounted。当一个对象可以被类scoped_refptr描述的对象引用时，它就必须要从基类RefCounted继承下来。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
template <class T> class RefCounted : public subtle::RefCountedBase { public: RefCounted() {} void AddRef() const { subtle::RefCountedBase::AddRef(); } void Release() const { if (subtle::RefCountedBase::Release()) { delete static_cast<const T*>(this); } } ...... }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
class BASE_EXPORT RefCountedBase { ...... protected: RefCountedBase() : ref_count_(0) ...... { } ...... void AddRef() const { ...... ++ref_count_; } bool Release() const { ...... if (--ref_count_ == 0) { ...... return true; } return false; } private: mutable int ref_count_; ...... }; |
线程安全版本
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> > class RefCountedThreadSafe : public subtle::RefCountedThreadSafeBase { public: ...... void AddRef() const { subtle::RefCountedThreadSafeBase::AddRef(); } void Release() const { if (subtle::RefCountedThreadSafeBase::Release()) { Traits::Destruct(static_cast<const T*>(this)); } } ...... private: friend struct DefaultRefCountedThreadSafeTraits<T>; static void DeleteInternal(const T* x) { delete x; } ...... }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
class BASE_EXPORT RefCountedThreadSafeBase { ...... protected: ...... void AddRef() const; // Returns true if the object should self-delete. bool Release() const; private: mutable AtomicRefCount ref_count_; ...... }; |
RefCountedThreadSafe类可以通过模板参数Traits指定一个类，当它引用的目标对象的引用计数等于0的时候，就会调用该参数Traits指定的类的静态成员函数Destruct来释放目标对象。
比如我们在一个线程创建一个T对象，这个T对象可能会被其它线程引用。当这个T对象的引用计数是在其它线程减少为0时，我们希望它不要在其它线程释放，而是要在创建线程进行释放，那么就可以通过指定参数Traits来实现。如果没有指定模板参数Traits，那么它的默认值就为DefaultRefCountedThreadSafeTraits。
|
1 2 3 4 5 6 7 8 |
template<typename T> struct DefaultRefCountedThreadSafeTraits { static void Destruct(const T* x) { ...... RefCountedThreadSafe<T, DefaultRefCountedThreadSafeTraits>::DeleteInternal(x); } }; |
scoped_refptr
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
template <class T> class scoped_refptr { public: typedef T element_type; 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(); } template <typename U> scoped_refptr(const scoped_refptr<U>& r) : ptr_(r.get()) { if (ptr_) ptr_->AddRef(); } ~scoped_refptr() { if (ptr_) ptr_->Release(); } T* get() const { return ptr_; } // Allow scoped_refptr<C> to be used in boolean expression // and comparison operations. operator T*() const { return ptr_; } T* operator->() const { assert(ptr_ != NULL); return ptr_; } scoped_refptr<T>& operator=(T* p) { // AddRef first so that self assignment should work if (p) p->AddRef(); T* old_ptr = ptr_; ptr_ = p; if (old_ptr) old_ptr->Release(); return *this; } ...... protected: T* ptr_; }; |
make_scoped_refptr
|
1 2 3 4 |
template <typename T> scoped_refptr<T> make_scoped_refptr(T* t) { return scoped_refptr<T>(t); } |
第二类：scoped_ptr
- 通过宏COMPILE_ASSERT以及IsNotRefCounted
类的静态成员变量value禁止scoped_ptr智能指针引用的目标对象从RefCounted类或者ThreadSafeRefCounted类继承下来，也就是不要求目标对象具有引用计数功能。 - 通过宏MOVE_ONLY_TYPE_FOR_CPP_03禁止scoped_ptr智能指针的copy语意，但是提供move语意。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
template <class T, class D = base::DefaultDeleter<T> > class scoped_ptr { MOVE_ONLY_TYPE_FOR_CPP_03(scoped_ptr, RValue) COMPILE_ASSERT(base::internal::IsNotRefCounted<T>::value, T_is_refcounted_type_and_needs_scoped_refptr); public: // The element and deleter types. typedef T element_type; typedef D deleter_type; // Constructor. Defaults to initializing with NULL. scoped_ptr() : impl_(NULL) { } // Constructor. Takes ownership of p. explicit scoped_ptr(element_type* p) : impl_(p) { } // Constructor. Allows initialization of a stateful deleter. scoped_ptr(element_type* p, const D& d) : impl_(p, d) { } ...... // Constructor. Move constructor for C++03 move emulation of this type. scoped_ptr(RValue rvalue) : impl_(&rvalue.object->impl_) { } ...... // Accessors to get the owned object. // operator* and operator-> will assert() if there is no current object. element_type& operator*() const { ...... return *impl_.get(); } element_type* operator->() const { ...... return impl_.get(); } element_type* get() const { return impl_.get(); } ...... template <typename PassAsType> scoped_ptr<PassAsType> PassAs() { return scoped_ptr<PassAsType>(Pass()); } private: ...... base::internal::scoped_ptr_impl<element_type, deleter_type> impl_; ...... }; |
scoped_ptr类将引用的目标对象间接保存在成员变量impl_描述的一个scoped_ptr_impl对象中。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
class scoped_ptr_impl { public: explicit scoped_ptr_impl(T* p) : data_(p) { } // Initializer for deleters that have data parameters. scoped_ptr_impl(T* p, const D& d) : data_(p, d) {} template <typename U typename V> scoped_ptr_impl(scoped_ptr_impl<U, V>* other) : data_(other->release(), other->get_deleter()) { ...... } ...... ~scoped_ptr_impl() { if (data_.ptr != NULL) { ...... static_cast<D&>(data_)(data_.ptr); } } ...... T* get() const { return data_.ptr; } ...... T* release() { T* old_ptr = data_.ptr; data_.ptr = NULL; return old_ptr; } ...... private: ...... struct Data : public D { explicit Data(T* ptr_in) : ptr(ptr_in) {} Data(T* ptr_in, const D& other) : D(other), ptr(ptr_in) {} T* ptr; }; Data data_; ...... }; |
|
1 2 |
scoped_ptr<T> p1(new T()); scoped_ptr<T> p2 = p1.Pass(); |
WeakPtr
WeakPtr类继承于WeakPtrBase类。WeakPtrBase类有一个成员变量ref_，它指向一个WeakReference对象。
一个对象如果需要被弱智能指针引用，那么它所属的类就必须要继承于SupportsWeakPtr类。SupportsWeakPtr类又是继承于SupportsWeakPtrBase类的。SupportsWeakPtrBase类有一个静态成员函数StaticAsWeakPtr，用来将一个间接继承于SupportsWeakPtr类的子类对象封装成一个WeakPtr弱智能指针。
SupportsWeakPtr类有一个成员函数AsWeakPtr，用来将一个SupportsWeakPtr子类对象封装成一个WeakPtr弱智能指针。在封装的过程中，需要用到成员变量weak_reference_owner_指向的一个WeakReferenceeOwner对象。
WeakReferenceeOwner类有一个成员变量flag_，它指向一个Flag对象。这个Flag对象有一个布尔类型的成员变量isvalid。当一个WeakReferenceeOwner对象所属的SupportsWeakPtr对象被销毁时，也就是它的析构函数被调用的时候，这个WeakReferenceeOwner对象的成员函数Invalidate就会被调用。WeakReferenceeOwner类的成员函数Invalidate又会进一步调用成员变量flag_指向的一个Flag对象的成员函数Invalidate，将该Flag对象的成员变量is_valid_的值设置为false，表示一个相应的SupportsWeakPtr对象被销毁了。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
template <typename T> class WeakPtr : public internal::WeakPtrBase { public: ...... template <typename U> WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other), ptr_(other.ptr_) { } T* get() const { return ref_.is_valid() ? ptr_ : NULL; } T& operator*() const { ...... return *get(); } T* operator->() const { ...... return get(); } ...... private: ...... WeakPtr(const internal::WeakReference& ref, T* ptr) : WeakPtrBase(ref), ptr_(ptr) { } ..... T* ptr_; }; |
|
1 2 3 4 5 6 7 8 9 |
class BASE_EXPORT WeakPtrBase { public: ...... protected: explicit WeakPtrBase(const WeakReference& ref); WeakReference ref_; }; |
本文为原创文章，版权归Aet所有，欢迎分享本文，转载请保留出处！
你可能也喜欢
- ♥ Chromium 界面05/08
- ♥ Cef：编译相关07/04
- ♥ base_timer04/24
- ♥ Chromium编译相关04/18
- ♥ base_json&&value05/19
- ♥ Chromium：鼠标事件的生成与处理07/19