QT 智慧指標 QPointer QScopedPointer QSharedPointer QWeakPointer QSharedDataPointer 隱式共享 顯示共享

永不停转發表於2024-03-22
QT指標

QPointer

QPointer 是一種受保護的指標，當其引用的物件被銷燬時，它會被自動清除（但是，銷燬引用物件還是必須手動delete）。QPointer所指向的物件必須是QObject或其派生類物件。

當多個指標指向同一個 Object 物件時，引用的物件可能被釋放掉，這時使用 QPointer 就可以安全的測試引用物件是否有效，防止發生指標空懸。

注意：Qt5 之前，QPointer 指向一個 QWidget 物件（或子類物件）時，QPointer 由 QWidget 的解構函式清除，Qt5 之後 由 QObject 的解構函式清除。在解構函式銷燬被跟蹤 QWidget 的子項之前，任何跟蹤 QWidget 的 QPointers 都不會被清除。

QPointer 提供的函式和運算子與普通指標的函式和運算子相同，但算術運算子+、-、 ++ 和 --除外（它們通常僅用於物件陣列）。

建立 QPointer 指標，可以使用建構函式、用 T * 賦值或相同型別的其他 QPointer 。QPointer 比較可以使用 == 和 ！=，或使用 isNull() 進行測試。可以使用 nullptr 或 *xx->member 取消引用。

QPointer 和普通指標可以混用，QPointer會自動轉換為指標*。可以把 QPointer 物件傳遞給需要 QWidget * 引數的函式。因此，宣告函式時沒有必要用 QPointer 作為引數，只需使用普通指標即可。

#include <QCoreApplication>
#include <QTimer>
#include <QDebug>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    QTimer *timer = new QTimer;
    // QPointer<QTimer> timer = new QTimer;
    delete timer;
    // 不使用QPointer時需要設定timer為NULL
    // timer=NULL;
    if(timer)
    {
        qInfo()<<"timer is not null";
    }
    else
    {
        qInfo()<<"timer is null";
    }
    return a.exec();
}

不使用QPointer時，輸出“Label is not null”，原因是，delete後未置空，易造成指標懸空。使用 QPointer 時，輸出"timer is null"。
在QPointer中 .是指標的屬性，-> 是物件的屬性。

QScopedPointer

QScopedPointer 類似於 C++ 11 中的 unique_ptr 用於管理動態分配的物件的獨佔所有權，即同一時間只能有一個QScopedPointer指向該物件。

QScopedPointer使用了RAII（資源獲取即初始化）技術，當QScopedPointer被銷燬時，它將自動釋放所管理的物件的記憶體。QScopedPointer不支援複製和賦值操作，這是為了避免在多個指標之間共享所有權的問題。如果需要在多個指標之間轉移所有權，應該使用QSharedPointer或QWeakPointer。

手動管理堆中分配的物件非常困難而且容易出錯，容易導致記憶體洩露。QScopedPointer是一個簡化記憶體管理的工具類，它透過將堆分配的空間賦值給基於棧的記憶體，通常稱為RAII（resource acquisition is initialization）。
QScopedPointer保證指向的物件在當前範圍消失時自動刪除。
下面的函式分配了堆記憶體，使用後手動刪除。

void myFunction(bool useSubClass)
 {
     MyClass *p = useSubClass ? new MyClass() : new MySubClass;
     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(useSubClass ? new MyClass() : new MySubClass);
     QScopedPointer<QIODevice> device(handsOverOwnership());

     if (m_value > 3)
         return;

     process(device);
 }

編譯器為QScopedPointer生成的程式碼與手動編寫的程式碼相同。delete程式碼是QScopedPointer的選項之一。QScopedPointer沒有賦值建構函式或賦值操作，以便清楚的表達所有權和生命週期。
C++ 中const修飾的指標也可以使用QScopedPointer來表示。

    const QWidget *const p = new QWidget();
    // 等價於
    const QScopedPointer<const QWidget> p(new QWidget());

    QWidget *const p = new QWidget();
    // 等價於
    const QScopedPointer<QWidget> p(new QWidget());

    const QWidget *p = new QWidget();
    // 等價於
    QScopedPointer<const QWidget> p(new QWidget());

自定義清理處理器：
使用malloc分配的陣列指標不能使用delete刪除，QScopedPointer的第二個模板引數可以用於自定義清理處理器。QT提供了以下自定義清理處理器：

  • QScopedPointerDeleter 預設處理器，使用delete刪除指標。
  • QScopedPointerArrayDeleter 使用delete []刪除。用於處理使用new [] 建立的指標。
  • QScopedPointerPodDeleter 使用free()刪除指標。用於處理使用malloc()建立的指標。
  • QScopedPointerDeleteLater 使用deleteLater()刪除指標。用於處理QEventLoop中使用的QObject指標。
    自定義清理處理器中必須提供一個public的靜態函式：public static function void cleanup(T *pointer)
 // QScopedPointer 使用 delete[] 刪除資料
 QScopedPointer<int, QScopedPointerArrayDeleter<int> > arrayPointer(new int[42]);

 // QScopedPointer 使用 free()釋放記憶體
 QScopedPointer<int, QScopedPointerPodDeleter> podPointer(reinterpret_cast<int *>(malloc(42)));

 // 該 struct 呼叫 "myCustomDeallocator" 刪除指標
 struct ScopedPointerCustomDeleter
 {
    static inline void cleanup(MyCustomClass *pointer)
    {
        myCustomDeallocator(pointer);
    }
 };

 // QScopedPointer 使用自定義清理處理器:
 QScopedPointer<MyCustomClass, ScopedPointerCustomDeleter> customPointer(new MyCustomClass);

QScopedPointer可以使用前置宣告的類，但是要保證QScopedPointer需要清理的時候前置宣告的類的解構函式可用。否則，編譯器將輸出解構函式不可用的警告。

 class MyPrivateClass; // 前置宣告 MyPrivateClass

class MyClass
{
private:
    QScopedPointer<MyPrivateClass> privatePtr; // QScopedPointer 使用前置宣告類

public:
    MyClass(); // OK
    inline ~MyClass() {} // VIOLATION - 解構函式不能使用inline修飾

private:
    Q_DISABLE_COPY(MyClass) // OK - 設定複製建構函式和賦值操作不可用，編譯器不會自動生成建構函式和賦值操作
};

成員函式

QScopedPointer::QScopedPointer(T *p = nullptr)

構造 QScopedPointer 例項，並指向p

QScopedPointer::~QScopedPointer()

銷燬QScopedPointer物件。刪除它指向的物件

T *QScopedPointer::data() const

返回QScopedPointer指向物件的值。QScopedPointer仍然指向該物件

T *QScopedPointer::get() const

與 data()功能相同

bool QScopedPointer::isNull() const

QScopedPointer指向的物件為nullptr時返回true

void QScopedPointer::reset(T *other = nullptr)

刪除已指向的物件並指向新物件other

QScopedArrayPointer

QScopedArrayPointer 與 QScopedPointer 類似，但是刪除指標時使用的時 delete[] 操作。QScopedArrayPointer 儲存的指標指向動態分配的陣列物件。如果我們指向的記憶體資料是一個陣列，這時可以用 QScopedArrayPointer。例如：

 void foo()
 {
     QScopedArrayPointer<int> i(new int[10]);
     i[2] = 42;
     ...
     return; // 此時我們定義的 integer 陣列會使用 delete[] 自動刪除
 }

QSharedPointer

QSharedPointer 相當於C++11 標準中的 shared_ptr， 用於管理動態分配的物件的共享所有權，即多個 QSharedPointer 物件可以指向同一個物件，並共享該物件的記憶體管理。它使用引用計數來追蹤物件的使用情況，當最後一個 QSharedPointer 物件被銷燬時，它將自動刪除它所持有的指標。由於使用了引用計數，QSharedPointer 能夠自動處理指標的生命週期，避免記憶體洩漏和空懸指標等問題，因此是Qt中最常用的智慧指標。

需要注意的是，QSharedPointer只能管理動態分配的物件的記憶體。如果我們將其用於指向棧物件或全域性物件，那麼它就不會自動釋放物件的記憶體，這可能會導致程式崩潰或記憶體洩漏。

建立 QSharedPointer 物件可以用普通指標、另一個 QSharedPointer 物件，也可以透過將 QWeakPointer 物件提升為強引用來建立。

執行緒安全

QSharedPointer 和 QWeekPointer 是可重入類，如果不進行同步，多個執行緒無法同時訪問指定的 QSharedPointer 物件或 QWeakPointer 物件。

多個 QSharedPointer 和 QWeekPointer 指向同一個物件的情況下，多個執行緒可以安全的訪問這些 QSharedPointer 和 QWeekPointer物件。QSharedPointer 採用的引用計數機制是原子操作，不需要手動同步。但是要注意，QSharedPointer 和 QWeekPointer 所指向的物件不一定是執行緒安全的，需要採用執行緒安全和重入規則來保證 QSharedPointer 和 QWeekPointer 所指向物件的安全。

其他指標類

Qt還提供了另外兩個指標包裝類： QPointer 和 QSharedDataPointer。它們彼此不相容，因為每個都有其非常不同的用例。

QSharedPointer 透過外部引用計數（即放置在物件外部的引用計數器）持有共享指標，指標值在 QSharedPointer 和 QWeekPointer 的所有例項之間共享。但是，指標指向的物件不應被視為共享的：都是同一個物件。QSharedPointer 不提供detach（隱式共享）或複製所引用物件的方法。

QSharedDataPointer 透過基類 QSharedData 內的引用計數持有共享資料的指標（共享資料派生自 QSharedData 類）。QSharedDataPointer 可以根據訪問型別對受保護資料執行detach（隱式共享）：如果不是讀訪問，則以原子方式建立一個副本以完成操作。

QExplicitlySharedDataPointer 是 QSharedDataPointer 的一個變數，QSharedDataPointer只有在 QExplicitlySharedDataPointer::detach() 時才會執行detach。

QScopedPointer 專為堆內分配、刪除物件設計，它持有指向堆分配物件的指標，並在其解構函式中刪除物件。 QScopedPointer 是輕量級的，它不使用額外的結構或引用計數。

QPointer 用於持有 QObject 派生物件的指標，但是一種弱引用。QWeakPointer 具有相同的功能，但不推薦使用該功能。

可選指標跟蹤
編譯除錯時可以開啟 QSharedPointer 的指標跟蹤功能。啟用後，QSharedPointer 會在全域性集合中註冊它跟蹤的所有指標。這樣就可以捕獲錯誤（例如：將同一指標分配給兩個 QSharedPointer 物件）。

開啟指標跟蹤功能需要在 include QSharedPointer 前定義宏QT_SHAREDPOINTER_TRACK_POINTERS。

即使沒有啟用指標跟蹤功能進行程式碼編譯，使用 QSharedPointer 跟蹤指標也是安全的。如果編譯的程式碼沒有開啟指標跟蹤功能，QSharedPointer 會從跟蹤器中刪除指標。

注意，指標跟蹤功能對多重繼承或虛擬繼承有限制（此時兩個不同的指標可以引用同一物件）。在這種情況下，如果指標被強制轉換為不同的型別並且其值發生更改，則 QSharedPointer 的指標跟蹤機制可能無法檢測到被跟蹤的物件是否為同一物件。

QWeakPointer

QWeakPointer 是對指標的弱引用，相當於C++11 標準中的 weak_ptr。QWeakPointer 不影響指標引用計數，可以用於驗證指標是否在已另一個上下文中被刪除。QWeakPointer物件的建立只能透過QSharedPointer賦值。QWeakPointer 用於追蹤指標，但並不代表指標本身，它不保證指標物件的有效性，也不提供轉換操作。如果要訪問 QWeakPointer 追蹤的指標，需要向將其提升為 QSharedPointer 並驗證該物件是否為 null，若物件不為 null，則可以使用該指標。QWeakPointer::toStrongRef()用於將 QWeakPointer 轉換為 QSharedPointer。
QWeakPointer 指向 QSharedPointer 所管理的物件，但不會增加物件的引用計數，也不會影響物件的生命週期。當物件被釋放時，QWeakPointer會自動被置為空指標，避免了空懸指標的問題。

#include <QSharedPointer>
#include <QWeakPointer>
#include <QDebug>

class MyClass
{
public:
    MyClass(int value) : m_value(value) {
        qDebug() << "MyClass constructor called with value" << m_value;
    }
    ~MyClass() {
        qDebug() << "MyClass destructor called with value" << m_value;
    }
    int getValue() const {
        return m_value;
    }

private:
    int m_value;
};

int main()
{
    QSharedPointer<MyClass> shared(new MyClass(20));
    QWeakPointer<MyClass> weak(shared);

    qDebug() << "Shared pointer value:" << shared->getValue();
    qDebug() << "Weak pointer value:" << weak.data()->getValue();

    shared.clear();
    // 此時，MyClass物件的引用計數為0，將被自動刪除，而此時 QWeakPointer 物件 weak 也為null。

    if (weak.isNull()) {
        qDebug() << "Weak pointer is null - object has been deleted"; //執行
    } else {
        qDebug() << "Weak pointer is not null - object still exists";
    }

    return 0;
}

QSharedDataPointer

QSharedDataPointer 用於簡化隱式共享類的實現。QSharedDataPointer 實現了執行緒安全的引用計數，保證了向可重入類新增 QSharedDataPointers 時不破壞的的可重入性。Qt 中很多類都採用了隱式共享來提升指標的訪問速度和記憶體使用效率。Qt 的容器類都使用了隱式共享，如 QList 、QVarLengthArray 、QStack 、QQueue、 QSet、 QMap、 QMultiMap、 QHash、 QMultiHash 。
例如，實現 Employee 類的隱式共享，需要以下步驟：

  1. 定義 Employee 類，並宣告一個 QSharedDataPointer 成員變數；
  2. 定義一個 EmployeeData 並繼承 QSharedData，將 Employee 需要的成員變數在 EmployeeData 中進行宣告。
#include <QSharedData>
#include <QString>

// EmployeeData 繼承自 QSharedData，QSharedData為其提供了一個引用計數器
// EmployeeData 要實現共享必須提供預設的建構函式、複製建構函式和解構函式
// 如果要對 Employee 類的使用者隱藏資料，應該把 EmployeeData 類宣告到獨立的 .h 檔案中
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;
};

class Employee
{
  public:
    Employee() { d = new EmployeeData; }
    // 該建構函式呼叫了 setId(id) 和 setName(name)， 2次修改共享資料，但是並不會觸發 copy on write
    Employee(int id, const QString &name) {
        d = new EmployeeData;
        setId(id); // 此時 EmployeeData 的引用計數為 1
        setName(name); // 引用計數為 1 ，不會 copy 共享資料
    }
    // 這個複製建構函式可以不用定義，編譯器會自動生成複製建構函式
    // 複製建構函式會對成員變數 d 進行賦值，賦值操作 =() 會增加共享資料的引用計數
    Employee(const Employee &other)
          : d (other.d)
    {
    }
    // 修改資料時，運算子 ->() 會自動呼叫 detach() ，如果共享資料的引用計數大於1，會自動copy一份資料用於修改。
    // 保證一個 Employee 物件對共享資料的修改不會影響其它Employee物件引用的共享資料
    void setId(int id) { d->id = id; }
    void setName(const QString &name) { d->name = name; }

    // 不修改 EmployeeData ，運算子 -> 不會觸發detach()
    int id() const { return d->id; }
    QString name() const { return d->name; }

  private:
    // Employee 只用一個成員變數，其它資料在 EmployeeData 中定義
    QSharedDataPointer<EmployeeData> d;
};

在上面的場景中，Employee 物件複製、賦值或作為引數傳遞時，QSharedDataPointer 自動增加引用計數。Employee 物件刪除或不在當前範圍時， QSharedDataPointer 自動減少引用計數。當引用計數為 0 時，EmployeeData 物件自動被刪除。當 Employee 的成員函式對成員變數 d 進行修改時，QSharedDataPointer 自動呼叫 detach() 操作，併為 Employee 物件複製出一份資料，保證 Employee 物件對資料的修改不會影響其它物件。如果 Employee 有多個成員函式都會修改成員變數 d，detach() 會被呼叫多次，但是隻有首次呼叫 detach() 時才會複製共享資料，因為第一次呼叫 detach() 後成員變數 d 指向新複製的資料，它的引用計數為 1。

隱式共享需要注意的問題：
看下面的程式碼，如果 e1 和 e2 都代表 id 為 1001 的資料，那麼將出現 1001 有 2 個不同 name 的問題，這在資料一致性上可能會有問題。這種問題需要使用顯示共享來解決，即在 Employee 類中宣告為顯示共享 QExplicitlySharedDataPointer d; 顯示共享不會自動執行 copy on write 操作。

#include "employee.h"

int main()
{
    Employee e1(1001, "Albrecht Durer");
    // e1 和 e2 指向同一個共享資料(1001, "Albrecht Durer")
    Employee e2 = e1;
    // setName 後成員變數 e1 將指向另一個資料(1001, "Hans Holbein")
    e1.setName("Hans Holbein");
}

可以考慮使用宏Q_DECLARE_TYPEINFO()將隱式共享類宣告為 movable 型別，例如上面的 Employee 類。

隱式共享的 iterator 問題：當使用 iterator 遍歷容器時，不能進行容器複製。例如：

QList<int> a, b;
// 構造一個用 0 初始化的 list
a.resize(100000); 

QList<int>::iterator i = a.begin();
// 下面是 iterator i 的錯誤使用方式

b = a;

// 與 STL 容器不同的是，如果此時執行 *i = 4 會發生隱式複製

a[0] = 5;
// 此時 a 已經從共享資料中分離出來，雖然 i 是 容器 a 的遍歷器，但實際上是 b 的遍歷器，此時 (*i) == 0

b.clear(); 
// 此時遍歷器 i 已經完全無效了

int j = *i; 
// 此時會出現 i 未定義的情況

// 如果使用的是 STL 的容器類 std::list<T> 不會發生上述情況，此時 (*i) == 5

QExplicitlySharedDataPointer

QExplicitlySharedDataPointer 用於簡化顯式共享類的實現。QExplicitlySharedDataPointer 實現了執行緒安全的引用計數，保證了向可重入類新增 QSharedDataPointers 時不破壞的的可重入性。
QExplicitlySharedDataPointer 與 QSharedDataPointer 類似，惟一不同的是 QExplicitlySharedDataPointer 的成員函式在出現寫操作時不會自動 copy 共享資料。QExplicitlySharedDataPointer 的 detach() 方法只能手動呼叫。QExplicitlySharedDataPointers 自動進行引用計數並在引用計數變為 0 時刪除共享資料。

參考文章：
Qt 智慧指標介紹： QSharedPointer、QWeakPointer 、QScopedPointer 、QPointer（附例項）
Qt 中的智慧指標
【圖解】Qt中的智慧指標
Qt 智慧指標學習（7種QT的特有指標）

相關文章