C++ Qt開發：使用順序容器類

原創 yshark 2023-12-10 14:32

當我們談論編程中的數據結構時，順序容器是不可忽視的一個重要概念。順序容器是一種能夠按照元素添加的順序來存儲和檢索數據的數據結構。它們提供了簡單而直觀的方式來組織和管理數據，爲程序員提供了靈活性和性能的平衡。

Qt 中提供了豐富的容器類，用於方便地管理和操作數據。這些容器類涵蓋了各種不同的用途，從簡單的動態數組到複雜的映射和集合。本章我們將主要學習順序容器，順序容器是一組強大而靈活的數據結構，用於按照元素添加的順序存儲和管理數據。Qt提供了多種順序容器，每種都具有獨特的特性，這些容器包括向量、列表、隊列、棧等，每種都有特定的適用場景。

當然了STL標準模板中也存在這些容器，Qt 的容器類與標準模板庫（STL）中的容器類有些相似，但也有一些不同之處。以下是 Qt 容器類相對於STL的一些特點和優勢：

  1. 可自動共享數據：
    • Qt 容器類使用了引用計數的技術，能夠自動共享數據，減少內存佔用。當一個容器對象複製另一個容器對象時，它們可以共享底層數據而不是進行深拷貝。
  2. 隱式共享：
    • Qt 容器類通過隱式共享實現了高效的數據共享。只有在發生寫操作時，纔會執行深拷貝，從而減少不必要的開銷。
  3. 可跨線程使用：
    • Qt 容器類支持在多線程環境中安全使用，通過顯式共享（QExplicitlySharedDataPointer）和不顯式共享兩種方式，方便在多線程應用中進行數據處理。
  4. 提供了一些額外的功能：
    • Qt 的容器類在標準容器的基礎上提供了一些額外的功能，例如對 Unicode 字符串的特殊支持（QString），以及一些便捷的成員函數，使得容器的使用更爲方便。
  5. 內存管理：
    • Qt 容器類負責管理其元素的內存，使得內存的分配和釋放不需要額外的手動管理，減輕了開發者的負擔。
  6. 直觀的 API 設計：
    • Qt 的容器類 API 設計考慮了 Qt 的整體框架，採用了一致而直觀的命名規範，使得使用者更容易理解和記憶容器類的接口。
  7. 與其他 Qt 類的集成：
    • Qt 容器類能夠無縫地與其他 Qt 類和框架集成，例如與信號和槽機制一起使用，使得在 Qt 應用程序中的開發更爲方便。

在某些特定的場景和需求下，STL 的容器類可能更適合使用。然而，在使用 Qt 框架的情況下，Qt 容器類通常能夠提供更好的集成和一些額外的特性。選擇使用哪種容器類取決於具體的項目需求和開發者的偏好。

1.1 QList 動態數組容器

QList 是 Qt 中常用的動態數組類，它提供了動態大小的數組，支持在列表的兩端和中間快速插入、刪除元素。適用於需要動態管理元素集合的場景，使得對列表的操作更加簡便。

以下是 QList 的一些常用函數：

函數 功能
QList::QList() 構造函數，創建一個空的 QList 對象。
QList::QList(const QList &other) 複製構造函數，創建一個與給定列表相同的 QList 對象。
QList::append(const T &value) 在列表末尾添加一個元素。
QList::prepend(const T &value) 在列表開頭添加一個元素。
QList::replace(int i, const T &value) 替換列表中索引爲 i 的元素爲給定的值。
QList::removeAt(int i) 移除列表中索引爲 i 的元素。
QList::removeOne(const T &value) 移除列表中第一個匹配給定值的元素。
QList::removeAll(const T &value) 移除列表中所有匹配給定值的元素。
QList::takeAt(int i) 移除並返回列表中索引爲 i 的元素。
QList::takeFirst() 移除並返回列表中的第一個元素。
QList::takeLast() 移除並返回列表中的最後一個元素。
QList::insert(int i, const T &value) 在列表中索引爲 i 的位置插入一個元素。
QList::contains(const T &value) const 判斷列表中是否包含給定值。
QList::count(const T &value) const 統計列表中匹配給定值的元素數量。
QList::indexOf(const T &value, int from = 0) const 返回給定值在列表中的第一個匹配項的索引，從指定位置 from 開始搜索。
QList::lastIndexOf(const T &value, int from = -1) const 返回給定值在列表中的最後一個匹配項的索引，從指定位置 from 開始反向搜索。
QList::isEmpty() const 判斷列表是否爲空。
QList::size() const 返回列表中元素的數量。
QList::clear() 清空列表，移除所有元素。
QList::operator=() 重載賦值運算符，將一個列表賦值給另一個列表。
QList::operator==() 重載相等運算符，判斷兩個列表是否相等。
QList::operator!=() 重載不等運算符，判斷兩個列表是否不相等。

以上是 QList 的一些常用函數及其功能，這些函數允許開發者對列表進行添加、刪除、替換、查找等操作，以滿足不同場景的需求。

1.1.1 主要特點

  1. 動態數組： QList 是動態大小的數組，可以根據需要自動調整大小。
  2. 泛型： QList 是泛型容器，可以存儲任意類型的數據。
  3. 可變大小： 列表的大小可以動態改變，元素的插入和刪除操作都很高效。
  4. 雙向迭代器： QList 提供了雙向迭代器，可以方便地從前往後或從後往前遍歷列表。

1.1.2 如何使用

如下所示的代碼中我定義了兩個QList容器，分別是StringPtrA和StringPtrB通過使用不同的容器操作函數對其進行簡單的增加插入替換刪除和移動操作，如下代碼所示；

#include <QCoreApplication>
#include <iostream>
#include <QList>

void Display(QList<QString> &ptr)
{
    std::cout << "-----------------------------" << std::endl;
    for(qint32 x=0;x<ptr.count();x++)
    {
        // std::cout << ptr[x].toStdString().data() << std::endl;
        std::cout << (ptr.at(x)).toStdString().data() << std::endl;
    }
    std::cout << std::endl;
}

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QList<QString> StringPtrA;
    QList<QString> StringPtrB;

    // 添加三個成員
    StringPtrA.append("admin");
    StringPtrA.append("guest");
    StringPtrA.append("lyshark");
    Display(StringPtrA);

    // 在首部插入hanter
    StringPtrA.prepend("hanter");
    Display(StringPtrA);

    // 在第0的位置插入lucy
    StringPtrA.insert(0,QString("lucy"));
    Display(StringPtrA);

    // 替換原來的admin爲全拼
    StringPtrA.replace(1,"Administrator");
    Display(StringPtrA);

    // 刪除第0個元素
    StringPtrA.removeAt(0);
    Display(StringPtrA);

    // 刪除首部和尾部
    StringPtrA.removeFirst();
    StringPtrA.removeLast();

    // 移動兩個變量
    StringPtrA.move(0,1);
    Display(StringPtrA);

    // 將兩個list容器對調交換
    StringPtrB = {"youtube","facebook"};
    StringPtrA.swap(StringPtrB);
    Display(StringPtrA);
    return a.exec();
}

上述代碼我們只是對字符串進行了鏈表管理，其實Qt中支持管理結構體，首先要定義一個特有的結構體MyStruct當結構體被賦值後就可以像數組一樣靈活的操作數據，當然在使用結構體時我們傳入的應該是QList<MyStruct>結構體的名字，在遍歷時可以有三種方式，第一種時傳統的循環依次輸出元素，這裏我們說說使用QListIterator和QMutableListIterator來輸出元素的區別。

#include <QCoreApplication>
#include <iostream>
#include <QList>
#include <QListIterator>
#include <QMutableListIterator>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QList<MyStruct> ptr;
    MyStruct str_ptr;

    str_ptr.uid = 1001;
    str_ptr.uname = "admin";
    ptr.append(str_ptr);

    str_ptr.uid = 1002;
    str_ptr.uname = "guest";
    ptr.append(str_ptr);

    // 使用傳統方式遍歷數據
    for(qint32 x=0;x<ptr.count();x++)
    {
        std::cout << ptr.at(x).uid << std::endl;
        std::cout << ptr[x].uname.toStdString().data() << std::endl;
    }

    // 使用只讀迭代器遍歷
    QListIterator<MyStruct> x(ptr);
    while(x.hasNext())
    {
        // peeknext讀取下一個節點,但不影響指針變化
        std::cout << x.peekNext().uid << std::endl;
        std::cout << (x.peekNext().uname).toStdString().data() << std::endl;
        // 最後將x指針指向下一個數據
        x.next();
    }

    // 使用讀寫迭代器:如果uid=1002則將guest改爲lyshark
    QMutableListIterator<MyStruct> y(ptr);
    while(y.hasNext())
    {
        // y.peekNext().uid = 9999;
        if(y.peekNext().uid == 1002)
        {
            y.peekNext().uname = "lyshark";
        }
        y.next();
    }
    return a.exec();
}

其實QListIterator 和 QMutableListIterator 都是用於遍歷 QList 容器的迭代器類。區別是QListIterator 是一個只讀迭代器，用於遍歷 QList 容器中的元素。它提供了一個方便的方式來訪問容器中的元素，支持前向和後向遍歷。而QMutableListIterator 是一個可變迭代器，除了支持讀取元素外，還允許修改 QList 中的元素。它提供了修改元素的接口，使得在遍歷的同時可以對容器進行修改。

QListIterator 主要函數和特點

  • QListIterator(const QList<T> &list): 構造函數，用於初始化迭代器並關聯到給定的 QList。
  • hasNext() const: 檢查是否有下一個元素。
  • next(): 返回當前元素並將迭代器移動到下一個元素。
  • peekNext() const: 返回當前元素但不移動迭代器。
  • toFront(): 將迭代器移動到列表的第一個元素。
  • toBack(): 將迭代器移動到列表的最後一個元素。

QMutableListIterator 主要函數和特點

  • QMutableListIterator(QList<T> &list): 構造函數，用於初始化可變迭代器並關聯到給定的 QList。
  • hasNext() const: 檢查是否有下一個元素。
  • next(): 返回當前元素並將迭代器移動到下一個元素。
  • peekNext() const: 返回當前元素但不移動迭代器。
  • toFront(): 將迭代器移動到列表的第一個元素。
  • toBack(): 將迭代器移動到列表的最後一個元素。
  • remove(): 移除迭代器當前位置的元素。
  • setValue(const T &value): 將迭代器當前位置的元素設置爲給定值。

這兩個迭代器類提供了方便而靈活的方式來遍歷和操作 QList 中的元素，根據需要選擇合適的迭代器。

1.2 QLinkeList 雙向鏈表容器

QLinkedList 是 Qt 中的雙向鏈表實現，與 QList 不同，它不是基於數組的動態容器，而是基於鏈表的數據結構。QLinkedList 提供了鏈表特有的靈活性，適用於需要在任意位置高效插入和刪除元素的場景。在一些訪問元素的場景中，由於鏈表的非連續存儲特性，可能比數組容器的訪問效率稍低。選擇使用 QLinkedList 還是其他容器，取決於具體的使用需求。

以下是 QLinkedList 的一些常用函數：

函數 功能
QLinkedList::QLinkedList() 構造函數，創建一個空的 QLinkedList 對象。
QLinkedList::QLinkedList(const QLinkedList &other) 複製構造函數，創建一個與給定鏈表相同的 QLinkedList 對象。
QLinkedList::append(const T &value) 在鏈表末尾添加一個元素。
QLinkedList::prepend(const T &value) 在鏈表開頭添加一個元素。
QLinkedList::replace(const_iterator before, const T &value) 替換鏈表中給定迭代器位置的元素爲給定的值。
QLinkedList::remove(const T &value) 移除鏈表中所有匹配給定值的元素。
QLinkedList::removeOne(const T &value) 移除鏈表中第一個匹配給定值的元素。
QLinkedList::removeAt(int i) 移除鏈表中索引爲 i 的元素。
QLinkedList::takeAt(int i) 移除並返回鏈表中索引爲 i 的元素。
QLinkedList::takeFirst() 移除並返回鏈表中的第一個元素。
QLinkedList::takeLast() 移除並返回鏈表中的最後一個元素。
QLinkedList::insert(const_iterator before, const T &value) 在鏈表中給定迭代器位置插入一個元素。
QLinkedList::contains(const T &value) const 判斷鏈表中是否包含給定值。
QLinkedList::count(const T &value) const 統計鏈表中匹配給定值的元素數量。
QLinkedList::indexOf(const T &value) const 返回給定值在鏈表中的第一個匹配項的索引。
QLinkedList::lastIndexOf(const T &value) const 返回給定值在鏈表中的最後一個匹配項的索引。
QLinkedList::isEmpty() const 判斷鏈表是否爲空。
QLinkedList::size() const 返回鏈表中元素的數量。
QLinkedList::clear() 清空鏈表，移除所有元素。
QLinkedList::begin() 返回指向鏈表第一個元素的迭代器。
QLinkedList::end() 返回指向鏈表最後一個元素之後的迭代器。

QLinkedList 提供了與 QList 類似的操作，但由於其基於雙向鏈表實現，特別適合於需要頻繁插入和刪除操作的場景。在使用上，QLinkedList 提供了一些額外的函數，如 replace、insert 等，可以更方便地操作鏈表中的元素。

1.2.1 主要特點

  1. 雙向鏈表： QLinkedList 使用雙向鏈表結構，每個節點存儲一個元素以及指向前後節點的指針，支持高效的插入和刪除操作。
  2. 泛型： QLinkedList 是泛型容器，可以存儲任意類型的數據。
  3. 可變大小： 鏈表的大小可以動態改變，元素的插入和刪除操作在任意位置都很高效。
  4. 雙向迭代器： QLinkedList 提供了雙向迭代器，可以方便地從前往後或從後往前遍歷鏈表。

1.2.2 如何使用

QLinkeList其實就是動態鏈表結構，數據的存儲非連續，訪問時無法直接使用下標定位，只能通過迭代器迭代尋找，這是其與QList的本質區別，其參數定義與QList基本一致，在使用上並沒有本質上的區別。

#include <QCoreApplication>
#include <iostream>
#include <QLinkedList>
#include <QLinkedListIterator>
#include <QMutableLinkedListIterator>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QLinkedList<MyStruct> ptr;
    MyStruct str_ptr;

    str_ptr.uid = 1001;
    str_ptr.uname = "admin";
    ptr.append(str_ptr);

    str_ptr.uid = 1002;
    str_ptr.uname = "guest";
    ptr.append(str_ptr);


    // 使用只讀迭代器遍歷: 從前向後遍歷
    QLinkedListIterator<MyStruct> x(ptr);
    while(x.hasNext())
    {
        std::cout << x.peekNext().uid << std::endl;
        x.next();
    }

    // 使用只讀迭代器遍歷: 從後向前遍歷
    for(x.toBack();x.hasPrevious();x.previous())
    {
        std::cout << x.peekPrevious().uid << std::endl;

    }

    // 使用STL風格的迭代器遍歷
    QLinkedList<MyStruct>::iterator y;
    for(y=ptr.begin();y!=ptr.end();++y)
    {
        std::cout << (*y).uid << std::endl;
    }

    // STL風格的只讀迭代器
    QLinkedList<MyStruct>::const_iterator z;
    for(z=ptr.constBegin();z!=ptr.constEnd();++z)
    {
        std::cout <<((*z).uname).toStdString().data()<< std::endl;
    }

    // 使用讀寫迭代器: 動態生成列表,每次對二取餘
    QLinkedList<int> Number = {1,2,3,4,5,6,7,8,9,10};
    QMutableLinkedListIterator<int> item(Number);

    // --> 從前向後輸出一次
    for(item.toFront();item.hasNext();item.next())
        std::cout << item.peekNext() << std::endl;

    // --> 將指針移動到最後然後判斷
    for(item.toBack();item.hasPrevious();)
    {
        if(item.previous() % 2==0)
            item.remove();
        else
            item.setValue(item.peekNext() * 10);
    }
    // --> 最後輸出出相加後的結果
    for(item.toFront();item.hasNext();)
    {
        std::cout << item.peekNext() << std::endl;
        item.next();
    }
    return a.exec();
}

1.3 QVector 動態數組容器

QVector 是Qt中的動態數組類，它提供了動態大小的數組，並在內部使用指針數組進行存儲。QVector 是一個靈活的動態數組類，適用於需要動態管理元素集合的場景，同時由於其連續存儲的特性，在訪問元素的效率上相對較高。

以下是 QVector 的一些常用函數：

函數 功能
QVector::QVector() 構造函數，創建一個空的 QVector 對象。
QVector::QVector(int size) 構造函數，創建一個包含 size 個元素的 QVector 對象。
QVector::QVector(int size, const T &value) 構造函數，創建一個包含 size 個元素，每個元素都是給定值的 QVector 對象。
QVector::QVector(const QVector &other) 複製構造函數，創建一個與給定向量相同的 QVector 對象。
QVector::append(const T &value) 在向量末尾添加一個元素。
QVector::prepend(const T &value) 在向量開頭添加一個元素。
QVector::replace(int i, const T &value) 替換向量中索引爲 i 的元素爲給定的值。
QVector::removeAt(int i) 移除向量中索引爲 i 的元素。
QVector::removeOne(const T &value) 移除向量中第一個匹配給定值的元素。
QVector::remove(const T &value) 移除向量中所有匹配給定值的元素。
QVector::takeAt(int i) 移除並返回向量中索引爲 i 的元素。
QVector::takeFirst() 移除並返回向量中的第一個元素。
QVector::takeLast() 移除並返回向量中的最後一個元素。
QVector::insert(int i, const T &value) 在向量中索引爲 i 的位置插入一個元素。
QVector::fill(const T &value, int size = -1) 使用給定值填充向量，如果指定了 size，則填充到指定大小。
QVector::contains(const T &value) const 判斷向量中是否包含給定值。
QVector::count(const T &value) const 統計向量中匹配給定值的元素數量。
QVector::indexOf(const T &value, int from = 0) const 返回給定值在向量中的第一個匹配項的索引，從指定位置 from 開始搜索。
QVector::lastIndexOf(const T &value, int from = -1) const 返回給定值在向量中的最後一個匹配項的索引，從指定位置 from 開始反向搜索。
QVector::isEmpty() const 判斷向量是否爲空。
QVector::size() const 返回向量中元素的數量。
QVector::clear() 清空向量，移除所有元素。
QVector::resize(int size) 更改向量的大小，如果新大小大於當前大小，會用默認值填充。
QVector::reserve(int size) 預留空間以容納指定數量的元素，可提高插入操作的性能。
QVector::squeeze() 釋放向量佔用的多餘空間。

QVector 提供了類似於 QList 的操作，但由於其底層使用連續存儲，因此在某些情況下性能更高。開發者可以根據具體的需求選擇適合的容器。

1.3.1 主要特點

  1. 動態數組： QVector 是動態大小的數組，可以根據需要自動調整大小。
  2. 連續存儲： 與 QLinkedList 不同，QVector 的元素在內存中是連續存儲的，這有助於提高訪問效率。
  3. 泛型： QVector 是泛型容器，可以存儲任意類型的數據。
  4. 可變大小： 數組的大小可以動態改變，元素的插入和刪除操作在末尾和中間都很高效。

1.3.2 如何使用

QVector 在內存中存儲連續的數據，類似於 C++ 中的 std::vector。該容器的使用與Qlist完全一致，但讀取性能要比Qlist更高，但在插入時速度最慢。

#include <QCoreApplication>
#include <iostream>
#include <QVector>
#include <QVectorIterator>
#include <QMutableVectorIterator>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QVector<MyStruct> ptr;
    MyStruct str_ptr;

    str_ptr.uid = 1001;
    str_ptr.uname = "admin";
    ptr.append(str_ptr);

    str_ptr.uid = 1002;
    str_ptr.uname = "guest";
    ptr.append(str_ptr);

    // 使用傳統方式遍歷
    for(qint32 x=0;x<ptr.count();x++)
    {
        std::cout << ptr.at(x).uid << std::endl;
        std::cout << ptr[x].uname.toStdString().data() << std::endl;
    }

    // 使用只讀迭代器遍歷: C++ STL寫法
    QVector<MyStruct>::const_iterator item;
    for(item = ptr.begin();item != ptr.end(); ++item)
    {
        std::cout << (*item).uid << std::endl;
        std::cout << (*item).uname.toStdString().data() << std::endl;
    }

    // 使用讀寫迭代器修改: C++ STL寫法
    QVector<MyStruct>::iterator write_item;
    for(write_item = ptr.begin();write_item !=ptr.end();++write_item)
    {
        if((*write_item).uid == 1001)
        {
            (*write_item).uname = "xxxx";
        }
        std::cout << (*write_item).uid << std::endl;
        std::cout << (*write_item).uname.toStdString().data() << std::endl;
    }

    return a.exec();
}

1.3.3 與QList的比較

  • 相似性： QVector 和 QList 在接口上非常相似，可以使用相同的函數進行元素的訪問、插入和刪除等操作。
  • 性能差異： 由於 QVector 的元素在內存中是連續存儲的，因此在順序訪問時，QVector 的性能通常比 QList 更高。但在中間插入元素時，QVector 的性能可能較差，因爲需要移動插入點之後的所有元素。
  • 適用場景： QVector 適用於需要頻繁進行順序訪問而較少進行中間插入操作的場景，例如對大量數據進行順序處理的情況。

1.4 QStack 棧容器

QStack 是 Qt 中的棧容器，它提供了棧（LIFO）的數據結構。該容器用於需要滿足後進先出規則的場景，例如在算法實現中，或者在某些數據處理過程中需要臨時存儲和恢復狀態。

以下是 QStack 的一些常用函數：

函數 功能
QStack::QStack() 構造函數，創建一個空的 QStack 對象。
QStack::QStack(const QStack &other) 複製構造函數，創建一個與給定棧相同的 QStack 對象。
QStack::push(const T &value) 在棧頂壓入一個元素。
QStack::pop() 彈出棧頂的元素。
QStack::top() const 返回棧頂的元素，不彈出。
QStack::isEmpty() const 判斷棧是否爲空。
QStack::size() const 返回棧中元素的數量。
QStack::clear() 清空棧，移除所有元素。
QStack::operator=() 重載賦值運算符，將一個棧賦值給另一個棧。
QStack::operator==() 重載相等運算符，判斷兩個棧是否相等。
QStack::operator!=() 重載不等運算符，判斷兩個棧是否不相等。

QStack 是一個後進先出（LIFO）的棧，提供了壓棧、彈棧等基本操作。棧是一種常見的數據結構，可以用於需要遵循後進先出原則的場景，例如遞歸函數調用時的存儲函數調用信息等。

1.4.1 主要特點

  1. 棧數據結構： QStack 是棧的實現，它遵循後進先出（Last In, First Out，LIFO）的原則。
  2. 泛型： QStack 是泛型容器，可以存儲任意類型的數據。
  3. 封閉性： QStack 提供的接口限制在棧頂進行插入和刪除操作，不允許在中間或底部插入或刪除元素。

1.4.2 如何使用

#include <QCoreApplication>
#include <iostream>
#include <QString>
#include <QStack>
#include <QQueue>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 定義並彈出QString類型數據
    QStack<QString> stack;

    stack.push("admin");
    stack.push("guest");

    std::cout << (stack.top()).toStdString().data()<<std::endl;
    while(!stack.isEmpty())
    {
        std::cout << (stack.pop()).toStdString().data() << std::endl;
    }

    // 定義並彈出一個結構類型數據
    QStack<MyStruct> struct_stack;
    MyStruct ptr;

    ptr.uid = 1001;
    ptr.uname = "admin";
    struct_stack.push(ptr);

    ptr.uid = 1002;
    ptr.uname = "guest";
    struct_stack.push(ptr);

    // 分別彈出數據並輸出
    while(!struct_stack.isEmpty())
    {
        MyStruct ref;

        ref = struct_stack.pop();
        std::cout << "uid = " << ref.uid << std::endl;
        std::cout << "uname = " << ref.uname.toStdString().data() << std::endl;
    }

    return a.exec();
}

1.5 QQueue 隊列容器

QQueue 是 Qt 中的隊列容器，它提供了隊列（FIFO）的數據結構。QQueue 可以用於需要滿足先進先出規則的場景，例如在任務調度、數據緩衝等應用中。

以下是 QQueue 的一些常用函數：

函數 功能
QQueue::QQueue() 構造函數，創建一個空的 QQueue 對象。
QQueue::QQueue(const QQueue &other) 複製構造函數，創建一個與給定隊列相同的 QQueue 對象。
QQueue::enqueue(const T &value) 在隊列尾部插入一個元素。
QQueue::dequeue() 移除隊列頭部的元素。
QQueue::head() const 返回隊列頭部的元素，不移除。
QQueue::isEmpty() const 判斷隊列是否爲空。
QQueue::size() const 返回隊列中元素的數量。
QQueue::clear() 清空隊列，移除所有元素。
QQueue::operator=() 重載賦值運算符，將一個隊列賦值給另一個隊列。
QQueue::operator==() 重載相等運算符，判斷兩個隊列是否相等。
QQueue::operator!=() 重載不等運算符，判斷兩個隊列是否不相等。

QQueue 是一個先進先出（FIFO）的隊列，提供了入隊、出隊等基本操作。隊列常用於需要按照先後順序處理元素的場景，例如任務隊列、消息隊列等。

1.5.1 主要特點

  1. 隊列數據結構： QQueue 是隊列的實現，它遵循先進先出（First In, First Out，FIFO）的原則。
  2. 泛型： QQueue 是泛型容器，可以存儲任意類型的數據。
  3. 封閉性： QQueue 提供的接口限制在隊列的前端進行插入，隊列的後端進行刪除操作。

1.5.2 如何使用

隊列就是先進後出，在使用上與普通容器保持一致，只是隊列的可用方法會更少一些。

#include <QCoreApplication>
#include <iostream>
#include <QString>
#include <QQueue>

struct MyStruct
{
    qint32 uid;
    QString uname;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QQueue<MyStruct> ptr;
    MyStruct queue_ptr;

    // 實現對結構體的入隊
    queue_ptr.uid = 1001;
    queue_ptr.uname = "admin";
    ptr.enqueue(queue_ptr);

    queue_ptr.uid = 1002;
    queue_ptr.uname = "guest";
    ptr.enqueue(queue_ptr);

    // 實現對結構體的出隊
    while(!ptr.isEmpty())
    {
        MyStruct ref;

        ref = ptr.dequeue();
        std::cout << "uid = " << ref.uid << std::endl;
        std::cout << "uname = " << ref.uname.toStdString().data() << std::endl;
    }

    return a.exec();
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Object.values()對象遍歷

Object.keys()  對象的遍歷  返回給定對象所有可枚舉屬性的數組；是屬性名組成的數組 let obj = { a: 1, b: 2, c: 3 }; Object.keys(obj).map((key) => {

雲悠 2024-05-13 14:33:01

c++踩方格-動態規劃基礎題

有一個方格矩陣，矩陣邊界在無窮遠處。我們做如下假設： a、每走一步時，只能從當前方格移動一格，走到某個相鄰的方格上； b、走過的格子立即塌陷無法再走第二次； c、只能向北、東、西三個方向走； 請問：如果允許在方格矩陣上走n步，共有多少種不同

Danlis 2024-05-13 14:30:51

[Mellanox] 安裝MLNX_OFED

[Mellanox] 安裝MLNX_OFED 雖然已經安裝過很多遍了，但是這裏還是再次寫一遍安裝過程，方便以後查閱。 Mellanox的這堆東西其實每個安裝起來都不難，難點在於版本要匹配。所以最重要的是我們要知道1.我們需要哪個版本的驅動；

CQzhangyu 2024-05-13 14:28:30

JPA使用pg數據庫時，bool字段不能跨庫遷移的解決方案

首先，大多數人的印象裏，hibernate作爲一個笨重學習成本高的近乎全自動的框架它的優點就是可以支持很多數據庫，但是最近研究發現，java中的boolean類型的字段，在mariadb/mysql 中爲bit 0/1,在sqlserver

漫漫人生路總會錯幾步 2024-05-13 14:27:30

【ubuntu】程序運行時的任務欄圖標

1. 快捷方式需要正確的配置StartupWMClass屬性，那麼如何獲取這個屬性呢？參考如下命令 xprop | grep WM_CLASS 將終端程序小窗運行上述命令，鼠標點擊哪個應用窗體就會獲取哪個窗體的名稱，有可能會有多個，多個

漫漫人生路總會錯幾步 2024-05-13 14:27:30

CodePen 的國內替代「筆.COOL」，一個功能完備、使用便捷的在線HTML/CSS/JS編輯器和作品分享平臺

筆.COOL，是一個最近在國內嶄露頭角的在線HTML/CSS/JS編輯器和作品分享平臺。 筆.COOL 提供了一個在線的 HTML、CSS 和 JavaScript 代碼編輯器。無需任何安裝，你只需打開網站，就可以開始編寫前端代碼。編輯

劉漢貴 2024-05-13 14:26:50

Visual Studio中的四款代碼格式化工具

前言 今天大姚給大家分享四款Visual Studio中的代碼格式化工具、擴展插件。大家可以在Visual Studio中的管理擴展或者插件市場下載安裝。 代碼格式化工具的作用 自動調整代碼的佈局和風格，以確保代碼具有統一的格式，提高可讀性

追逐時光 2024-05-13 14:21:59

幹了 2 年多 Java 外包，終於脫離了！

大家好，我是R哥。 金三銀四結束了，上個月分享了一個 35K 入職的面試輔導案例： 35K*14 薪入職了，這公司只要不裁員，我能一直呆下去。。 今天再分享一個上個月讓人很有成就感的面試輔導 case： 外包、空窗四個月、薪資 10k、

Java技術棧 2024-05-13 14:21:19

mysql 存json數據會自動亂序的解決方案

https://blog.csdn.net/whatzhang007/article/details/110089447 總結就是一個字: 啓用json類的保存方式.改成logntext即可. 例如我的方穹項目的表設計: 不吐槽不行, 真

張博的博客 2024-05-13 14:19:49

【Python】保存gym截圖

如果想做基於圖像cnn的深度強化學習，需要拿到gym的截圖，下面是兩種截圖方法。 1. 利用render結果生成圖像： import gym import warnings import os from PIL import Image

Dsp Tian 2024-05-13 14:11:08

win10 22H2

Windows 10 update history https://support.microsoft.com/en-gb/topic/windows-10-update-history-8127c2c6-6edf-4fdf-8b9f-0f

ChuckLu 2024-05-13 14:06:58

【譯】使用 GitHub Copilot 作爲你的編碼 GPS

　　GitHub Copilot 是一個改變遊戲規則的人工智能助手，可以徹底改變您在 Visual Studio 中的編碼流程。在我們的視頻系列中，Bruno  Capuano 探討了這個智能編碼夥伴如何幫助您更有效地編寫代碼，同時保持質量

MeteorSeed 2024-05-13 14:06:38

兩個有趣的AI項目

　　最近看到一個比較有意思的 AI 項目，叫 AI 時間線，顧名思義，就是藉助 AI 來創建某個關鍵字的時間線。主頁界面很簡單，就是一個輸入框。 　　 　　我在輸入辛亥革命後，就會生成下圖的時間線，將辛亥革命的各個關鍵點都列了出來。我看到這

咖啡機（K.F.J） 2024-05-13 14:05:57

從油猴腳本管理器的角度審視Chrome擴展

從油猴腳本管理器的角度審視Chrome擴展 在之前一段時間，我需要藉助Chrome擴展來完成一個需求，當時還在使用油猴腳本與瀏覽器擴展之間調研了一波，而此時恰好我又有一些做的還可以的油猴腳本 TKScript (點個star吧 😁)，相對會

WindrunnerMax 2024-05-13 14:05:17

一文學會 Kubernetes Pod 的生命週期管理（轉載）

收穫 瞭解 Pod 的狀態（Status） 瞭解 pod 階段（Phase） 瞭解 Pod conditions 　　瞭解容器狀態（Status） 保持容器健康 　　瞭解容器自動重啓 　　使用探活（liveness）探針（Probe）檢查容

PowerCoder 2024-05-13 14:03:07