QWeakPointer

先介绍QWeakPointer，是因为QPointer和QSharedPointer的实现都依赖于QWeakPointer

作用

1、为QPointer和QSharedPointer提供了弱引用计数的功能.
2、解除循环引用

QWeakPointer 类持有对共享指针的弱引用。
QWeakPointer 是对 C++ 中指针的自动弱引用。它不能用于直接取消引用指针，但可以用于验证指针是否已在另一个上下文中被删除。
QWeakPointer 对象只能通过 QSharedPointer 的赋值来创建(因为没有重载operator*和->)。
需要注意的是，QWeakPointer 没有提供自动转换操作符来防止错误发生。即使 QWeakPointer 跟踪一个指针，它本身也不应该被认为是一个指针，因为它不能保证指向的对象保持有效。
因此，要访问 QWeakPointer 正在跟踪的指针，您必须首先将其提升为 QSharedPointer 并验证结果对象是否为空。 QSharedPointer 保证对象不被删除，所以如果你得到一个非空对象，你可以使用指针。有关示例，请参见 QWeakPointer::toStrongRef()。
QWeakPointer 还提供了 QWeakPointer::data() 方法，该方法返回跟踪的指针而不确保它保持有效。如果您可以通过外部方式保证对象不会被删除（或者如果您只需要指针值）那你就可以使用它。友情提示：使用 toStrongRef() 创建 QSharedPointer 的成本较高。

构造函数

观察QWeakPointer的构造函数部分，处于public部分的构造函数有如下几个，可以看出都是不允许带参构造或者参数并不是我们期望的指针类型.(所以，QWeakPointer从设计上就不是直接提供给我们使用的)

  1. // 无参构造
  2. inline QWeakPointer() Q_DECL_NOTHROW : d(nullptr), value(nullptr) { }
  4. // 拷贝构造,弱引用计数+1
  5. QWeakPointer(const QWeakPointer &other) Q_DECL_NOTHROW : d(other.d), value(other.value)
  6.     { if (d) d->weakref.ref(); }
  8. // 拷贝构造,弱引用计数+1
  9. inline QWeakPointer(const QSharedPointer<T> &o) : d(o.d), value(o.data())
  10.     { if (d) d->weakref.ref();}
  12. template <class X>
  13. inline QWeakPointer(const QWeakPointer<X> &o) : d(nullptr), value(nullptr)
  14.     { *this = o; }
  16. template <class X>
  17. inline QWeakPointer(const QSharedPointer<X> &o) : d(nullptr), value(nullptr)
  18.     { *this = o; }

唯一的可用的构造函数处于private部分，好处是这里添加了两个友元类型QPointer和QSharedPointer，关于友元我们应该不用多做介绍(我是你的朋友，你的就是我的，但你不是我的朋友，所以我的还是我的^_^)

  1. private:
  3. #if defined(Q_NO_TEMPLATE_FRIENDS)
  4. public:
  5. #else
  6.     template <class X> friend class QSharedPointer;
  7.     template <class X> friend class QPointer;
  8. #endif
  10.     template <class X>
  11.     inline QWeakPointer &assign(X *ptr)
  12.     { return *this = QWeakPointer<X>(ptr, true); }
  14. #ifndef QT_NO_QOBJECT
  15.     // 私有构造函数
  16.     template <class X>
  17.     inline QWeakPointer(X *ptr, bool) : d(ptr ? Data::getAndRef(ptr) : nullptr), value(ptr)
  18.     { }
  19. #endif
  21.     inline void internalSet(Data *o, T *actual)
  22.     {
  23.         if (d == o) return;
  24.         if (o)
  25.             o->weakref.ref();
  26.         if (d && !d->weakref.deref())
  27.             delete d;
  28.         d = o;
  29.         value = actual;
  30.     }
  32.     // 唯二的成员变量
  33.     Data *d;
  34.     T *value;
  35. };

QWeakPointer的数据成员只有两个，分别用于在私有构造函数中，ptr为模板参数类型的指针，d=ptr ? Data::getAndRef(ptr) : nullptr;

  1. typedef QtSharedPointer::ExternalRefCountData Data;

看下ExternalRefCountData的定义，从名字大概看出来这是一个关于引用计数的结构，用于保存引用计数相关的数据。
注意下这里的weakref和strongref都是QBasicAtomicInt类型的，关于QAtom系列的几个类，有时间会单独列一章。

  1.     struct ExternalRefCountData
  2.     {
  3.         typedef void (*DestroyerFn)(ExternalRefCountData *);
  4.         QBasicAtomicInt weakref;
  5.         QBasicAtomicInt strongref;
  6.         DestroyerFn destroyer;
  8.         inline ExternalRefCountData(DestroyerFn d)
  9.             : destroyer(d)
  10.         {
  11.             strongref.store(1);
  12.             weakref.store(1);
  13.         }
  14.         inline ExternalRefCountData(Qt::Initialization) { }
  15.         ~ExternalRefCountData() { Q_ASSERT(!weakref.load()); Q_ASSERT(strongref.load() <= 0); }
  17.         void destroy() { destroyer(this); }
  19. #ifndef QT_NO_QOBJECT
  20.         Q_CORE_EXPORT static ExternalRefCountData *getAndRef(const QObject *);
  21.         Q_CORE_EXPORT void setQObjectShared(const QObject *, bool enable);
  22.         Q_CORE_EXPORT void checkQObjectShared(const QObject *);
  23. #endif
  24.         inline void checkQObjectShared(...) { }
  25.         inline void setQObjectShared(...) { }
  27.         inline void operator delete(void *ptr) { ::operator delete(ptr); }
  28.         inline void operator delete(void *, void *) { }
  29.     };

QWeakPointer的带参构造函数是私有的，引用计数结构体使用getAndRef方法获取，value保存ptr。getAndRef只接受QObject*作为参数，因此就限制了QWeakPointer私有构造时，传入的指针类型必须为QObject.
从下面的代码我们不难发现QObjectPrivate中保存了一个ExternalRefCountData的指针，此指针存在时，引用计数+1。不存在时，创建一个新的指针，并赋值引用计数(强引用为-1,弱引用为2,这个数字回头再说)后，返回此指针。

  1. QtSharedPointer::ExternalRefCountData *QtSharedPointer::ExternalRefCountData::getAndRef(const QObject *obj)
  2. {
  3.     Q_ASSERT(obj);
  4.     QObjectPrivate *d = QObjectPrivate::get(const_cast<QObject *>(obj));
  5.     Q_ASSERT_X(!d->wasDeleted, "QWeakPointer", "Detected QWeakPointer creation in a QObject being deleted");
  7.     ExternalRefCountData *that = d->sharedRefcount.load();
  8.     if (that) {
  9.         that->weakref.ref();
  10.         return that;
  11.     }
  13.     // we can create the refcount data because it doesn't exist
  14.     ExternalRefCountData *x = new ExternalRefCountData(Qt::Uninitialized);
  15.     x->strongref.store(-1);
  16.     x->weakref.store(2);  // the QWeakPointer that called us plus the QObject itself
  17.     if (!d->sharedRefcount.testAndSetRelease(0, x)) {
  18.         // ~ExternalRefCountData has a Q_ASSERT, so we use this trick to
  19.         // only execute this if Q_ASSERTs are enabled
  20.         Q_ASSERT((x->weakref.store(0), true));
  21.         delete x;
  22.         x = d->sharedRefcount.loadAcquire();
  23.         x->weakref.ref();
  24.     }
  25.     return x;
  26. }

这个时候我们看一下QObject析构时候的处理，强引用计数置0，弱引用计数-1，如果减为0则delete掉ExternalRefCountData

  1. QObject::~QObject()
  2. {
  3.     Q_D(QObject);
  4.     d->wasDeleted = true;
  5.     d->blockSig = 0; // unblock signals so we always emit destroyed()
  7.     QtSharedPointer::ExternalRefCountData *sharedRefcount = d->sharedRefcount.load();
  8.     if (sharedRefcount) {
  9.         if (sharedRefcount->strongref.load() > 0) {
  10.             qWarning("QObject: shared QObject was deleted directly. The program is malformed and may crash.");
  11.             // but continue deleting, it's too late to stop anyway
  12.         }
  14.         // indicate to all QWeakPointers that this QObject has now been deleted
  15.         sharedRefcount->strongref.store(0);
  16.         if (!sharedRefcount->weakref.deref())
  17.             delete sharedRefcount;
  18.     }

析构函数

弱引用计数-1，如果减为0则delete掉d ，但是不会delete掉value

  1. inline ~QWeakPointer() { if (d && !d->weakref.deref()) delete d; }

接触循环引用

下面的例子，按照我们对智能指针的理解，在运行后Parent和Children指针均应被释放，但实际结果会告诉我们并没有

  1. #include <QApplication>
  2. #include <QScopedPointer>
  3. #include <QDebug>
  5. class Children;
  6. class Parent {
  7. public:
  8.     Parent() {
  10.     }
  12.     ~Parent() {
  13.         qDebug() << __FUNCTION__ ;
  14.     }
  16.     QSharedPointer<Children> ptr;
  17. };
  19. class Children {
  20. public:
  21.     Children() {
  23.     }
  24.     ~Children() {
  25.         qDebug() << __FUNCTION__ ;
  26.     }
  28.     QSharedPointer<Parent> ptr;
  29. };
  32. int main(int argc, char *argv[])
  33. {
  34.     QApplication a(argc, argv);
  36.     // 模拟一个作用域
  37.     {
  38.         QSharedPointer<Parent> p(new Parent());
  39.         QSharedPointer<Children> c(new Children());
  41.         if(p && c){
  42.             p->ptr = c;
  43.             c->ptr = p;
  44.         }
  45.     }
  46.     // 出了作用域，此时指针内容销毁，猜想一下输出内容是什么
  48.     return a.exec();
  49. }

对上面的代码稍作改动，将Parent和Children中的成员变量指针改成QWeakPointer，此时Parent和Children均被析构

  1. #include <QApplication>
  2. #include <QScopedPointer>
  3. #include <QDebug>
  5. class Children;
  6. class Parent {
  7. public:
  8.     Parent() {
  10.     }
  12.     ~Parent() {
  13.         qDebug() << __FUNCTION__ ;
  14.     }
  16.     // 这里将QSharedPointer改为QWeakPointer
  17.     QWeakPointer<Children> ptr;
  18. };
  20. class Children {
  21. public:
  22.     Children() {
  24.     }
  25.     ~Children() {
  26.         qDebug() << __FUNCTION__ ;
  27.     }
  29.     // 这里将QSharedPointer改为QWeakPointer
  30.     QWeakPointer<Parent> ptr;
  31. };
  34. int main(int argc, char *argv[])
  35. {
  36.     QApplication a(argc, argv);
  38.     // 模拟一个作用域
  39.     {
  40.         QSharedPointer<Parent> p(new Parent());
  41.         QSharedPointer<Children> c(new Children());
  43.         if(p && c){
  44.             p->ptr = c;
  45.             c->ptr = p;
  46.         }
  47.     }
  48.     // 再猜测一下输出内容
  50.     return a.exec();
  51. }

两个对象互相使用一个 QSharedPointer成员变量指向对方（你中有我，我中有你）。由于QSharedPointer是一个强引用的计数型指针，只有当引用数为0时，就会自动删除指针释放内存，但是如果循环引用，就会导致QSharedPointer指针的引用永远都不能为0，这时候就会导致内存无法释放。
所以QWeakPointer诞生了，它就是为了打破这种循环的。并且，在需要的时候变成QSharedPointer，在其他时候不干扰QSharedPointer的引用计数。它没有重载 * 和 -> 运算符，因此不可以直接通过 QWeakPointer 访问对象，典型的用法是通过 lock() 成员函数来获得 QSharedPointer，进而使用对象。

源码赏析

  1. template <class T>
  2. class QWeakPointer
  3. {
  4.     typedef T *QWeakPointer:: *RestrictedBool;
  5.     typedef QtSharedPointer::ExternalRefCountData Data;
  7. public:
  8.     typedef T element_type;
  9.     typedef T value_type;
  10.     typedef value_type *pointer;
  11.     typedef const value_type *const_pointer;
  12.     typedef value_type &reference;
  13.     typedef const value_type &const_reference;
  14.     typedef qptrdiff difference_type;
  16.     bool isNull() const Q_DECL_NOTHROW { return d == nullptr || d->strongref.load() == 0 || value == nullptr; }
  17.     operator RestrictedBool() const Q_DECL_NOTHROW { return isNull() ? nullptr : &QWeakPointer::value; }
  18.     bool operator !() const Q_DECL_NOTHROW { return isNull(); }
  19.     T *data() const Q_DECL_NOTHROW { return d == nullptr || d->strongref.load() == 0 ? nullptr : value; }
  21.     inline QWeakPointer() Q_DECL_NOTHROW : d(nullptr), value(nullptr) { }
  22.     inline ~QWeakPointer() { if (d && !d->weakref.deref()) delete d; }
  24. #ifndef QT_NO_QOBJECT
  25.     // special constructor that is enabled only if X derives from QObject
  26. #if QT_DEPRECATED_SINCE(5, 0)
  27.     template <class X>
  28.     QT_DEPRECATED inline QWeakPointer(X *ptr) : d(ptr ? Data::getAndRef(ptr) : nullptr), value(ptr)
  29.     { }
  30. #endif
  31. #endif
  33. #if QT_DEPRECATED_SINCE(5, 0)
  34.     template <class X>
  35.     QT_DEPRECATED inline QWeakPointer &operator=(X *ptr)
  36.     { return *this = QWeakPointer(ptr); }
  37. #endif
  39.     QWeakPointer(const QWeakPointer &other) Q_DECL_NOTHROW : d(other.d), value(other.value)
  40.     { if (d) d->weakref.ref(); }
  41. #ifdef Q_COMPILER_RVALUE_REFS
  42.     QWeakPointer(QWeakPointer &&other) Q_DECL_NOTHROW
  43.         : d(other.d), value(other.value)
  44.     {
  45.         other.d = nullptr;
  46.         other.value = nullptr;
  47.     }
  48.     QWeakPointer &operator=(QWeakPointer &&other) Q_DECL_NOTHROW
  49.     { QWeakPointer moved(std::move(other)); swap(moved); return *this; }
  50. #endif
  51.     QWeakPointer &operator=(const QWeakPointer &other) Q_DECL_NOTHROW
  52.     {
  53.         QWeakPointer copy(other);
  54.         swap(copy);
  55.         return *this;
  56.     }
  58.     void swap(QWeakPointer &other) Q_DECL_NOTHROW
  59.     {
  60.         qSwap(this->d, other.d);
  61.         qSwap(this->value, other.value);
  62.     }
  64.     inline QWeakPointer(const QSharedPointer<T> &o) : d(o.d), value(o.data())
  65.     { if (d) d->weakref.ref();}
  66.     inline QWeakPointer &operator=(const QSharedPointer<T> &o)
  67.     {
  68.         internalSet(o.d, o.value);
  69.         return *this;
  70.     }
  72.     template <class X>
  73.     inline QWeakPointer(const QWeakPointer<X> &o) : d(nullptr), value(nullptr)
  74.     { *this = o; }
  76.     template <class X>
  77.     inline QWeakPointer &operator=(const QWeakPointer<X> &o)
  78.     {
  79.         // conversion between X and T could require access to the virtual table
  80.         // so force the operation to go through QSharedPointer
  81.         *this = o.toStrongRef();
  82.         return *this;
  83.     }
  85.     template <class X>
  86.     bool operator==(const QWeakPointer<X> &o) const Q_DECL_NOTHROW
  87.     { return d == o.d && value == static_cast<const T *>(o.value); }
  89.     template <class X>
  90.     bool operator!=(const QWeakPointer<X> &o) const Q_DECL_NOTHROW
  91.     { return !(*this == o); }
  93.     template <class X>
  94.     inline QWeakPointer(const QSharedPointer<X> &o) : d(nullptr), value(nullptr)
  95.     { *this = o; }
  97.     template <class X>
  98.     inline QWeakPointer &operator=(const QSharedPointer<X> &o)
  99.     {
  100.         QSHAREDPOINTER_VERIFY_AUTO_CAST(T, X); // if you get an error in this line, the cast is invalid
  101.         internalSet(o.d, o.data());
  102.         return *this;
  103.     }
  105.     template <class X>
  106.     bool operator==(const QSharedPointer<X> &o) const Q_DECL_NOTHROW
  107.     { return d == o.d; }
  109.     template <class X>
  110.     bool operator!=(const QSharedPointer<X> &o) const Q_DECL_NOTHROW
  111.     { return !(*this == o); }
  113.     inline void clear() { *this = QWeakPointer(); }
  115.     inline QSharedPointer<T> toStrongRef() const { return QSharedPointer<T>(*this); }
  116.     // std::weak_ptr compatibility:
  117.     inline QSharedPointer<T> lock() const { return toStrongRef(); }
  119. #if defined(QWEAKPOINTER_ENABLE_ARROW)
  120.     inline T *operator->() const { return data(); }
  121. #endif
  123. private:
  125. #if defined(Q_NO_TEMPLATE_FRIENDS)
  126. public:
  127. #else
  128.     template <class X> friend class QSharedPointer;
  129.     template <class X> friend class QPointer;
  130. #endif
  132.     template <class X>
  133.     inline QWeakPointer &assign(X *ptr)
  134.     { return *this = QWeakPointer<X>(ptr, true); }
  136. #ifndef QT_NO_QOBJECT
  137.     template <class X>
  138.     inline QWeakPointer(X *ptr, bool) : d(ptr ? Data::getAndRef(ptr) : nullptr), value(ptr)
  139.     { }
  140. #endif
  142.     inline void internalSet(Data *o, T *actual)
  143.     {
  144.         if (d == o) return;
  145.         if (o)
  146.             o->weakref.ref();
  147.         if (d && !d->weakref.deref())
  148.             delete d;
  149.         d = o;
  150.         value = actual;
  151.     }
  153.     Data *d;
  154.     T *value;
  155. };

附录

本文资料为以下链接的总结，可能大量借鉴其中内容，因此不敢说原创，仅做分享之用，如有侵权，告知必删。

Qt—智能指针
Qt智能指针—QWeakPointer
QWeakPointer Class