Qt中智能指针介绍和使用

Qt 中的智能指针比C++11 标准中提供的功能还要强大，所以如果我们使用 Qt 作为基础库，那么就没有必要使用C++11 的智能指针。
Qt 的智能指针包括：
    QSharedPointer
    QScopedPointer
    QScopedArrayPointer
    QWeakPointer
    QPointer
    QSharedDataPointer

QSharedPointer
QSharedPointer 大体相当于C++11 标准中的 shared_ptr。是在 Qt 4.5 中引入的，所以只要我们的 Qt 版本大于 Qt 4.5 就可以使用这个类。
要使用这个智能指针类，首先要包含对应的头文件：
#include <QSharedPointer>
QSharedPointer 内部维持着对拥有的内存资源的引用计数。比如有 5个 QSharedPointer 拥有同一个内存资源，那么这个引用计数就是 5。这时如果一个 QSharedPointer 离开了它的作用域，那么就还剩下 4 个 QSharedPointer 拥有这个内存资源，引用计数就变为了 4。 当引用计数下降到 0 时，这个内存资源就被释放了。
QSharedPointer 的构造函数有如下这几种。
QSharedPointer();
QSharedPointer(X *ptr);
QSharedPointer(X *ptr, Deleter deleter);
QSharedPointer(std::nullptr_t);
QSharedPointer(std::nullptr_t, Deleter d);
QSharedPointer(const QSharedPointer<T> &other);
QSharedPointer(const QWeakPointer<T> &other);
因此我们可以：
- 构造一个空的 QSharedPointer
- 通过一个普通指针来构造一个 QSharedPointer
- 用另一个 QSharedPointer 来构造一个 QSharedPointer
- 用一个 QWeakPointer 来构造一个 QSharedPointer

并且，我们可以指定 Deleter。因此 QSharedPointer 也可以用于指向 new[] 分配的内存。

QSharedPointer 是线程安全的，因此即使有多个线程同时修改 QSharedPointer 对象也不需要加锁。这里要特别说明一下，虽然 QSharedPointer 是线程安全的，但是 QSharedPointer 指向的内存区域可不一定是线程安全的。所以多个线程同时修改 QSharedPointer 指向的数据时还要应该考虑加锁的。
下面是个 QSharedPointer 的例子，演示了如何自定义 Deleter。
  static void doDeleteLater(MyObject *obj)
  {
      obj->deleteLater();
  }
  void otherFunction()
  {
      QSharedPointer<MyObject> obj = QSharedPointer<MyObject>(new MyObject, doDeleteLater);
      // continue using obj
      obj.clear();    // calls obj->deleteLater();
  }
QSharedPointer 使用起来就像是普通的指针。唯一让我不满意的地方就是 QSharedPointer 不支持指向一个数组。
QScopedPointer
QScopedPointer 类似于 C++ 11 中的 unique_ptr。当我们的内存数据只在一处被使用，用完就可以安全的释放时就可以使用 QScopedPointer。
比如下面的代码：
void Function(bool useSubClass)
  {
      Class *p = useClass ? new Class() : new SubClass;
      QIODevice *device = handsOverOwnership();

      if (m_value > 3) {
          delete p;
          delete device;
          return;
      }

      try {
          process(device);
      }
      catch (...) {
          delete p;
          delete device;
          throw;
      }

      delete p;
      delete device;
  }

如果用 QScopedPointer，就可以简化为：

void myFunction(bool useSubClass)
  {
      // assuming that MyClass has a virtual destructor
      QScopedPointer<MyClass> p(useClass ? new Class() : new MyClass);
      QScopedPointer<QIODevice> device(handsOverOwnership());

      if (m_value > 3)
          return;

      process(device);
  }

QScopedArrayPointer

如果我们指向的内存数据是一个数组，这时可以用 QScopedArrayPointer。QScopedArrayPointer 与 QScopedPointer 类似，用于简单的场景。

例如下面这个例子：

void foo()
  {
      QScopedArrayPointer<int> i(new int[10]);
      i[2] = 42;
      ...
      return; // our integer array is now deleted using delete[]
  }

QPointer

QPointer 与其他的智能指针有很大的不同。其他的智能指针都是为了自动释放内存资源而设计的。 QPointer 智能用于指向 QObject 及派生类的对象。当一个 QObject 或派生类对象被删除后，QPointer 能自动把其内部的指针设为 0。这样我们在使用这个 QPointer 之前就可以判断一下是否有效了。

为什么非要是 QObject 或派生类呢，因为 QObject 可以构成一个对象树，当这颗对象树的顶层对象被删除时，它的子对象自动的被删除。所以一个 QObject 对象是否还存在，有时并不是那么的明显。有了 QPointer 我们在使用一个对象之前，至少可以判断一下。

要特别注意的是，当一个 QPointer 对象超出作用域时，并不会删除它指向的内存对象。这和其他的智能指针是不同的。

下面给一个简单的例子：

    QPointer<QLabel> label = new QLabel;
      label->setText("&Status:");
      ...
      if (label)
          label->show();

QSharedDataPointer

QSharedDataPointer 这个类是帮我们实现数据的隐式共享的。我们知道 Qt 中大量的采用了隐式共享和写时拷贝技术。比如下面这个例子：

QString str1 = "abcdefg";
QString str2 = str1;
QString str2[2] = 'X';

第二行执行完后，str2 和 str1 指向的同一片内存数据。当第三句执行时，Qt 会为 str2 的内部数据重新分配内存。这样做的好处是可以有效的减少大片数据拷贝的次数，提高程序的运行效率。

Qt 中隐式共享和写时拷贝就是利用 QSharedDataPointer 和 QSharedData 这两个类来实现的。

比如我们有个类叫做 Employee，里面有些数据希望能够利用隐式共享和写时拷贝技术。那么我们可以把需要隐式共享的数据封装到另一个类中，比如叫做 EmployeeData，这个类要继承自 QSharedData。

class EmployeeData : public QSharedData
  {
    public:
      EmployeeData() : id(-1) { }
      EmployeeData(const EmployeeData &other)
          : QSharedData(other), id(other.id), name(other.name) { }
      ~EmployeeData() { }

      int id;
      QString name;
  };

这个例子中，id 和 name 就是我们要隐式共享和写时拷贝的数据。那么 Employee 类需要这么来实现。

class Employee
{
public:
    Employee() { d = new EmployeeData; }
    Employee(const Employee &other)
            : d (other.d)
      {
      }
    Employee(int id, const QString &name) 
    {
        d = new EmployeeData;
        setId(id);
        setName(name);
    }
    Employee(const Employee &other)
        : d (other.d)
    {
    }
    void setId(int id) { d->id = id; }
    void setName(const QString &name) { d->name = name; }

    int id() const { return d->id; }
    QString name() const { return d->name; }

private:
    QSharedDataPointer<EmployeeData> d;
};

我们对 Employee 中数据的访问都要通过 d。那么当需要修改 id 或 name 时，QSharedDataPointer 类自动的调用 detach() 方法来完成数据的拷贝。d (other.d) 则完成了隐式共享的功能。

看到了吧，就这么简单。如果这些功能都要自己实现的话，代码量可是不小的。

于这个类有关的还有个 QExplicitlySharedDataPointer 这个类用到的机会更少，所以就不多做介绍了，请大家自己看 Qt 的帮助文档。
QWeakPointer

最后来简单介绍一下 QWeakPointer。这个类用到的机会不多。（说实话我不太会用这个类，下面的介绍都是网上抄的.）

QWeakPointer 是为配合 QSharedPointer 而引入的一种智能指针，它更像是 QSharedPointer 的一个助手(因为它不具有普通指针的行为，没有重载operator*和->)。它的最大作用在于协助 QSharedPointer 工作，像一个旁观者一样来观测资源的使用情况。