QT開發（二十五）——QT模板庫

QT開發（二十五）——QT模板庫

1、QTL模板庫簡介

QT模板庫（QT Template Library 簡稱QTL）是一套提供對象容器的模板。

QTL提供了對象的鏈表、對象的矢量（動態數組）、從一個類型到另外一個類型的映射（或稱爲字典）和相關的迭代器和算法。容器是包含和管理其它對象的一個對象，而且提供迭代器對被包含的對象進行訪問。

1、QT容器類簡介

    容器是可以在內存中存儲其餘特定類型的對象的對象，通常是通用的模板類。QT提供了本身的一套容器類，即在QT的應用程序中，可使用標準C++的STL，也可使用QT的容器類。QT容器類的好處在於提供了平臺無關的行爲，以及隱式數據共享技術。所謂平臺無關，即QT容器類不因編譯器的不一樣而具備不一樣的實現；所謂「隱式數據共享」，即「寫時複製copy on write」，容許在容器類中使用傳值參數，而不會發生額外的性能損失。QT容器類提供了Java風格的迭代器，也提供了STL風格的迭代器，方便用戶選擇本身習慣的編碼方式。在一些嵌入式平臺，STL每每是不可用的，只能使用Qt提供的容器類，除非本身建立。

    QT容器中的存儲數據類型有要求，數據必須是能夠賦值的數據類型，即數據類型必須有一個默認的構造函數（無參數構造函數）、一個複製構造函數（拷貝構造）和一個賦值操做符函數。基本的數據類型(int和double等)和QT部分數據類型（如 QString、QDate、QTime等）能夠存儲在容器中，QObject及其子類（如QWidget和Qdialog等）是不能夠存儲在容器中的，但QObject及其子類的指針能夠存儲在容器中。

class Movie
{
public:
        Movie(const QString &title = "", int duration = 0);
        void setTitle(const QString &title) { myTitle = title; }
        QString title() const { return myTitle; }
        void setDuration(int duration) { myDuration = duration; }
        QString duration() const { return myDuration; }
private:
        QString myTitle;
        int myDuration;
};

    Movie類能夠放入QT容器中，第一，雖然Movie類的構造函數有兩個參數，但都有默認值，Movie()寫法是容許的，因此有默認構造函數；第二，Movie類沒有顯示定義拷貝構造函數和賦值操做符，但C++編譯器會提供一個默認的實現。

2、迭代器

    QT容器類提供了兩種風格的迭代器：Java風格和STL風格。Java風格迭代器比較容易使用，STL風格迭代器則能夠用在一些通用算法中，功能比較強大。

每個容器類都有對應的迭代器：只讀迭代器和讀寫迭代器。

Java風格迭代器

Containers	Read-only iterator	Read-write iterator
QList<T> QQueue<T>	QListIterator<T>	QMutableListIterator<T>
QLinkedList<T>	QLinkedListIterator<T>	QMutableLinkedListIterator<T>
QVector<T> QStack<T>	QVectorIterator<T>	QMutableVectorIterator<T>
QSet<T>	QSetIterator<T>	QMutableSetIterator<T>
QMap<Key,T> QMultiMap<Key, T>	QMapIterator<Key, T>	QMutableMapIterator<Key, T>
QHash<Key,T> QMultiHash<Key, T>	QHashIterator<Key, T>	QMutableHashIterator<Key, T>

    Java風格迭代器不指向任何元素，而是指向第一個元素以前、兩個元素之間或者是最後一個元素以後的位置。

QList<double> list;

// ...

QListIterator<double> i(list);

while (i.hasNext()) {

        doSomethingWith(i.next());

}

STL風格迭代器

C<T>::iterator和C<T>::const_iterator。

Containers	Read-only iterator	Read-write iterator
QList<T> QQueue<T>	QList<T>::const_iterator	QList<T>::iterator
QLinkedList<T>	QLinkedList<T>::const_iterator	QLinkedList<T>::iterator
QVector<T> QStack<T>	QVector<T>::const_iterator	QVector<T>::iterator
QSet<T>	QSet<T>::const_iterator	QSet<T>::iterator
QMap<Key, T> QMultiMap<Key, T>	QMap<Key, T>::const_iterator	QMap<Key, T>::iterator
QHash<Key, T> QMultiHash<Key, T>	QHash<Key, T>::const_iterator	QHash<Key, T>::iterator

    STL風格迭代器begin()函數返回指向第一個元素的STL風格的遍歷器，而end()函數則會返回指向最後一個元素以後位置的STL風格的遍歷器。

QList<double>::iterator i = list.begin();

while (i != list.end())

{

        *i = qAbs(*i);

        ++i;

}

3、隱式數據共享

    QT全部容器類以及其餘類如：QByteArray、QBrush、QFont、QImage、QPixmap和QString都使用了隱式數據共享技術。隱式數據共享使得類在參數和返回值中使用傳值方式至關高效。

    爲了正確使用隱式數據共享，須要創建一個良好的編程習慣。首先，對list或者vector使用at()函數而不是[]操做符進行只讀訪問。 緣由是[]操做符既能夠是左值又能夠是右值，這讓Qt容器很難判斷究竟是左值仍是右值，而at()函數是不能做爲左值的，所以能夠進行隱式數據共享。其次，對於begin()、end()以及其餘一些非const容器，在數據改變時QT會進行深複製，要儘量使用const_iterator, constBegin()和constEnd()。

2、順序存儲容器

1、QVector

    QVector類是一個提供動態數組的模板類。QVector<T>使用連續內存來保存數據項，分配所需內存的方式與動態內存分配的方式相比，減小了在時間和內存上的開銷。

    QVector<T>和其餘QT容器、大部分值類型的類（包括 QString）同樣，使用隱式共享。但拷貝一個QVector時，內部只是拷貝了一個指針和遞增了引用計數，只有修改數據時，纔會進行深拷貝，隱式共享也稱寫時複製。

    隱式共享是QVector和std::vector<T>的主要區別。

    QBasicAtomic類用於保存引用計數，支持原子操做（線程安全），確保隱式共享能夠跨線程使用。 QT在不一樣架構下使用匯編語言來實現QBasicAtomic類。

    爲了不每次容器增加時都分配內存， QVector<T> 會一次分配超過須要的內存。若是參數T是可拷貝類型（能夠經過memcpy() or memmove()進行拷貝的對象，例如C++原類型和QT隱式共享類）， QVector<T>使用 realloc()一次再分配 4096字節的增量。 這是由於現代操做系統當從新分配一個內存時並不拷貝整塊數據，只是物理內存頁面簡單的從新排序，第一頁和最後一頁須要進行拷貝。

    對於不可拷貝數據類型，QVector<T>以每次增加50%的方式，確保在頻繁調用append()函數時平均算法複雜度爲 O(n)。

    若是用QVector<T>儲存自定義的類型， QT會假定自定義數據類型是不可拷貝類型。對於自定義可拷貝的數據類型，可使用 Q_DECLARE_TYPEINFO()宏來聲明。

class MyClass
{
...
private:
MyClassPrivateData *data;
};
Q_DECLARE_TYPEINFO(MyClass, Q_MOVABLE_TYPE);

    Q_DECLARE_TYPEINFO()宏也可用於其餘容器，最典型的就是 QList<T>。若是自定義數據類型是沒有定義構造函數和析構函數的POD類型，可以用memcpy 和memmove函數進行拷貝，能夠用把自定義類型聲明爲元類型而不是可拷貝類型。

class MyClass
{
...
private:
int x;
int y;
};
Q_DECLARE_TYPEINFO(MyClass, Q_PRIMITIVE_TYPE);

    若是T是元類型， QVector<T>不會調用構造函數和析構函數，對可拷貝類型的優化對元類型都有效。

    QVector<T>提供了[]的重載，但對於只讀操做，因爲不須要深拷貝，使用at（）函數的效率會較高。

QVector<double> v(2);
 v[0] = 1.1;
 v[1] = 1.2;

    若是實現不知道vector的長度，能夠建立一個空參數的vector，而後使用append()函數添加數據：

QVector<double> v;
 v.append(1.1);
 v.append(1.2);

    QVector<T>重載了<<，能夠直接使用<<操做符

QVector<double> v;
 v << 1.1 << 1.2;

    若是QVector<T>中的數據沒有被顯式地賦值，那麼，數據項將使用加入類的默認構造函數進行初始化，若是是基本數據類型和指針，則初始化爲0

    QVector類的全部成員函數是可重入的。

    QVector主要成員函數以下：

QVector()

QVector(int size)

QVector(int size, const T & value)

QVector(const QVector<T> & other)

構造函數

QVector<T> fromList(const QList<T> & list)[static]

QList<T> toList() const

QVector與QList轉換函數

QVector<T> fromStdVector(const std::vector<T> & vector)[static]

std::vector<T> toStdVector() const

QVector與std::vector轉換函數

const_iterator constBegin() const

返回指向vector中第一個元素的STL風格的const迭代器

const_iterator constEnd() const

返回指向vector中最後一個元素的下一個的STL風格的const迭代器

bool QVector::contains ( const T & value ) const

Vector中若是有value元素則返回true

void QVector::append ( const T & value )

在vector尾部插入元素value

void QVector::prepend ( const T & value )

在vector的開始插入值爲value的元素

const T & QVector::at ( int i ) const

返回vector中索引i的元素值

iterator QVector::begin ()

const_iterator QVector::begin () const

返回指向vector中第一個元素的迭代器

iterator QVector::end ()

const_iterator QVector::end () const

返回一個指向vector中最後元素的下一個的指針

int QVector::capacity () const

Vector中可以存儲元素的最大值

int QVector::size () const

返回vector中存儲的元素的數量

void QVector::resize ( int size )

設置vector的大小爲size，若是size大於當前vector的大小，則在尾部增長元素，若是size小於當前vector的大小，則在尾部刪除元素。

void QVector::clear ()

刪除vector中全部的元素並釋放所佔內存

bool QVector::startsWith ( const T & value ) const

若是vector非空，第一個元素爲value，返回true

bool QVector::endsWith ( const T & value ) const

若是vector非空，最後一個元素爲value，返回true

int QVector::count ( const T & value ) const

int QVector::count () const

返回vector中值爲value的元素的個數

T * QVector::data ()

const T * QVector::data () const

返回vector中存儲數據的指針

const T * QVector::constData () const

返回一個指向vector中數據的const指針

bool QVector::empty () const

返回vector是否爲空，兼容STL風格

bool QVector::isEmpty () const

返回vector是否爲空

void QVector::insert ( int i, const T & value )

在vector中的i位置插入值爲value的元素

void QVector::remove ( int i )

刪除vector中位置i的元素

void QVector::insert ( int i, int count, const T & value )

在vector中位置i插入count個值爲value的元素

void QVector::remove ( int i, int count )

在vector中刪除從位置i開始的count個元素

2、QLinekedList

    QLinkedList<T>提供一個雙向鏈表，插入刪除操做在常數時間完成。

    雖然插入、刪除操做是常數時間，但 QLinkedList<T>只有在對象數量超過200對象時才能看出優點。對於小於200個對象的鏈表， QList<T>提供更好的性能、耗費更小的內存。

    QLinkedList<T>的優勢是數據的插入和刪除很快，可是隨機位置值的訪問會很慢。與QVector<T>不一樣，QLinkedList<T>並無提供重載的[]操做符，只能使用append()函數，或者<<操做符進行數據的添加。

    QLinkedList全部成員函數是可重入的。

    QLinkedList主要成員函數以下：

QLinkedList::QLinkedList ()

QLinkedList::QLinkedList ( const QLinkedList<T> & other )

構造函數

QLinkedList<T> QLinkedList::fromStdList(const std::list<T> & list)[static]

std::list<T> QLinkedList::toStdList () const

QLinkedList與std::list的轉換函數

void QLinkedList::append ( const T & value )

在list尾部插入值爲value的元素

void QLinkedList::prepend ( const T & value )

在list開頭插入值爲value的元素

iterator QLinkedList::insert(iterator before, const T & value)

在迭代器before指向的項的前面插入值爲value的項，返回指向插入項的迭代器

三、QList

    QList是典型的數組鏈表，不是真正意義上的鏈表。

    根據參數T的不一樣， QList 有兩種組織方式。一般狀況下， QList 有一個指針數組用於保存用new操做符在堆上分配的對象的指針，使得在容器的中間插入和刪除的速度比參數爲不可拷貝類型的QVector快，由於指針是能夠用內存拷貝。

    QList<T>是一個同時擁有QVector<T>和QLinkedList<T>的大多數有點的順序存儲容器類。既能夠像QVector<T>同樣支持快速的隨機訪問，重載了[]操做符，提供了索引訪問的方式；也能夠像 QLinkedList<T>同樣，支持快速的添加、刪除操做。除非咱們須要進行在很大的集合的中間位置的添加、刪除操做，或者是須要全部元素在內存中必須連續存儲，不然咱們應該一直使用Qlist<T>。

    爲了確保下標訪問速度，QList內部使用數組實現。

    QList<T>有幾個特殊的狀況。一個是QStringList，這是 QList<QString>的子類，提供針對QString的不少特殊操做。QStack<T>和 QQueue<T>分別實現了數據結構中的堆棧和隊列，前者具備push(), pop(), top()函數，後者具備enqueue(), dequeue(), head()函數。

    QList全部成員函數是可重入的。

    QList主要成員函數以下：

QList::QList ()

QList::QList(const QList<T> & other)

QList<T> QList::fromSet(const QSet<T> & set) [static]

QList<T> QList::fromStdList(const std::list<T> & list) [static]

QList<T> QList::fromVector(const QVector<T> & vector) [static]

QSet、std::list、QVector類型轉換爲QList

QSet<T> QList::toSet() const

std::list<T> QList::toStdList() const

QVector<T> QList::toVector() const

QList轉換爲QSet、std::list、QVector

void QList::append(const T & value)

在list尾部插入值爲value的元素

void QList::append(const QList<T> & value)

在list尾部插入value鏈表

四、 QStack

QStack繼承自QVector，提供後入先出LIFO的棧式結構，在QVector的基礎上增長了push()、pop()、top()成員函數。

QStack全部成員函數是可重入的。

QStack主要成員函數以下：

QStack::QStack()

構造函數

T QStack::pop()

出棧操做，返回棧頂元素，刪除棧頂元素

void QStack::push(const T & t)

壓棧操做，添加元素t到棧頂

T & QStack::top()

const T & QStack::top() const

返回棧頂元素的引用

 

5、QQueue

    QQueue繼承自QList，提供先入先出FIFO的隊列結構，在QList的基礎上增長了enqueue()、dequeue()、head()成員函數。

    QQueue全部成員函數是可重入的。

    QQueue主要成員函數以下：

QQueue::QQueue ()

構造函數

T QQueue::dequeue ()

出隊列操做，返回隊列中頭元素的值並刪除

void QQueue::enqueue ( const T & t )

入隊列操做，添加t到隊列尾部

T & QQueue::head ()

const T & QQueue::head () const

返回隊列頭元素的引用

3、關聯存儲容器

    關聯存儲容器中存儲的通常是二元組，即鍵值對。QT提供兩種關聯容器類型：QMap<K, T>和QHash<K, T>。

1、QMap

 QMap是一個以升序鍵順序存儲鍵值對的數據結構，QMap原型爲QMap<K, T>模板。

QMap<Key, T>保存一個根據主鍵排序的鏈表（主鍵，值），提供 O(log n)的查找時間常數。 QMap<Key, T>內部使用的是一個跳錶的數據結構， 與紅黑樹提供相似的算法複雜度和性能。早期版本的 QMap 用的是紅黑樹，可是跳錶代碼簡潔、節省內存。

class QMap<K,T>,QMap中的鍵值對根據Key進行了排序，QMap中Key類型必須重載operator<。

QMap使用方法以下：

 

   QMap<QString, int> map;
 
    map.insert("key 2", 2);
    map.insert("key 1", 1);
    map.insert("key 0", 0);
 
    QList<QString> kList = map.keys();
 
    for(int i=0; i<kList.count(); i++)
    {
        qDebug() << kList[i];
    }
 
    QList<int> vList = map.values();
 
    for(int i=0; i<vList.count(); i++)
    {
        qDebug() << vList[i];
    }
 
    QMapIterator<QString, int> it(map);
 
    while( it.hasNext() )
    {
        it.next();
 
        qDebug() << it.key() << " : " << it.value();
    }

    QMap使用注意：

經過Key獲取value時：

    Key存在時返回對應的value

    Key不存在時返回值類型所對應的「零」值

插入鍵值對時：

    key存在時更新value的值

    Key不存在時插入新的鍵值對

    QMap<K, T>是一種鍵-值對的數據結構，實際上使用跳錶skip-list實現，按照K進行升序的方式進行存儲。使用QMap<K, T>的insert()函數能夠向QMap<K, T>中插入數據。

QMap<QString, int> map;

map.insert("eins", 1);

map.insert("sieben", 7);

map.insert("dreiundzwanzig", 23);

QMap<K, T>也重載了[]運算符，能夠按照數組的賦值方式進行使用

map["eins"] = 1;

map["sieben"] = 7;

map["dreiundzwanzig"] = 23;

    []操做符一樣也能夠像數組同樣取值。若是在一個非const的map中，使用[]操做符取一個不存在的Key的值，則這個Key會被自動建立，並將其關聯的value賦予一個空值。若是要避免這種狀況，請使用QMap<K, T>的value()函數：

    QMap<K, T>中的K和T能夠是基本數據類型，如int，double，能夠是指針，或者是擁有默認構造函數、拷貝構造函數和賦值運算符的類。而且K必需要重載<運算符，由於QMap<K, T>須要按K升序進行排序。

    QMap<K, T>提供了keys()和values()函數，能夠得到鍵的集合和值的集合。這兩個集合都是使用QList做爲返回值的。

    QMap全部成員函數是可重入的。

QMap主要成員函數以下：

QMap::QMap ()

QMap::QMap ( const QMap<Key, T> & other )

QMap::QMap ( const std::map<Key, T> & other )

構造函數

std::map<Key, T> QMap::toStdMap () const

QMap轉換爲std::map

QList<Key> QMap::uniqueKeys () const

返回map中全部惟一的key的鏈表

2、QMultiMap

    QMultiMap繼承自QMap，容許一個key索引多個value。

    QMap全部成員函數是可重入的。

QMap主要的成員函數以下：

QMultiMap::QMultiMap ()

QMultiMap::QMultiMap ( const QMap<Key, T> & other )

構造函數

QMap<Key, T>::const_iterator QMultiMap::constFind(const Key & key, const T & value) const

QMap<Key, T>::const_iterator QMultiMap::constFind(const Key & key) const

返回map中鍵爲key的迭代器

bool QMultiMap::contains ( const Key & key, const T & value ) const

bool QMultiMap::contains ( const Key & key ) const

map中鍵是否存在鍵爲key的鍵

int QMultiMap::count ( const Key & key, const T & value ) const

int QMultiMap::count ( const Key & key ) const

int QMultiMap::count () const

返回map中鍵爲key的數量

int QMultiMap::remove ( const Key & key, const T & value )

int QMultiMap::remove ( const Key & key )

刪除map中鍵爲key的鍵值對

3、QHash

QHash是QT中的Hash數據結構，QHash原型類類模板QHash<K, T>。

QHash中的鍵值對在內部無序排列，key類型必須重載operator==,key對象必須重載全局哈希函數qHash（）。

QHash使用方法以下：

   

 QHash<QString, int> hash;
 
    hash.insert("key 2", 2);
    hash.insert("key 1", 1);
    hash.insert("key 0", 0);
 
    QList<QString> kList = hash.keys();
 
    for(int i=0; i<kList.count(); i++)
    {
        qDebug() << kList[i];
    }
 
    QList<int> vList = hash.values();
 
    for(int i=0; i<vList.count(); i++)
    {
        qDebug() << vList[i];
    }
 
    hash["key 4"] = 4;
 
    QHash<QString, int>::const_iterator i;
 
    for(i=hash.constBegin(); i!=hash.constEnd(); ++i)
    {
        qDebug() << i.key() << " : " << i.value();
    }

    QHash<K, T>是使用散列存儲的鍵-值對，QHash<K, T>接口同QMap<K, T>基本同樣，但實現需求不一樣。QHash<K, T>的查找速度比QMap<K, T>快不少，而且存儲是不排序的。對於QHash<K, T>而言，K的類型必須重載了==操做符，而且必須被全局函數qHash()所支持，qHash()函數用於返回key的散列值。QT已經爲int、指針、 QChar、QString和QByteArray實現了qHash()函數。

    QHash<K, T>會自動地爲散列分配一個初始大小，而且在插入數據或者刪除數據的時候改變散列的大小。咱們可使用reserve()函數擴大散列，使用 squeeze()函數將散列縮小到最小大小(這個最小大小其實是可以存儲這些數據的最小空間)。在使用時，咱們可使用reserve()函數將數據 項擴大到咱們所指望的最大值，而後插入數據，完成以後使用squeeze()函數收縮空間。

    QHash<K, T>一樣也是單值類型的，可使用insertMulti()函數或者QMultiHash<K, T>類來爲一個鍵插入多個值。另外，除了QHash<K, T>，Qt也提供了QCache<K, T>來提供緩存，QSet<K>用於僅存儲key的狀況。這兩個類同QHash<K, T>同樣具備K的類型限制。

    QHash全部成員函數是可重入的。

QHash主要成員函數以下：

QHash::QHash ()

QHash::QHash ( const QHash<Key, T> & other )

構造函數

const Key QHash::key ( const T & value ) const

const Key QHash::key ( const T & value, const Key & defaultKey ) const

返回hash中value的key

QList<Key> QHash::keys () const

返回hash中全部的key的鏈表

QList<Key> QHash::keys ( const T & value ) const

返回hash中包含value的全部key的鏈表

QList<Key> QHash::uniqueKeys () const

返回hash中全部惟一的鍵的鏈表

const T QHash::value ( const Key & key ) const

返回鍵爲key的值

const T QHash::value ( const Key & key, const T & defaultValue ) const

返回鍵爲key的值，若是沒有key，返回defaultValue

QList<T> QHash::values () const

返回hash中全部的值的鏈表

QList<T> QHash::values ( const Key & key ) const

返回hash中鍵爲key的元素的值的鏈表

4、QMultiHash

    QMultiHash繼承自QHash，是QHash的輔助類，提供多值hash，容許一個hash值由多個值對應。

    與QHash不一樣，QMultiHash不提供[]操做重載。

    QMultiHash全部成員函數是可重入的。

    QMultiHash主要成員函數以下：

QMultiHash::QMultiHash()

QMultiHash::QMultiHash(const QHash<Key, T> & other)

構造函數

QHash<Key, T>::const_iterator QMultiHash::constFind(const Key & key, const T & value) const

QHash<Key, T>::const_iterator QMultiHash::constFind(const Key & key) const

查找multihash中鍵爲key，值爲value的項，返回迭代器

bool QMultiHash::contains ( const Key & key, const T & value ) const

bool QMultiHash::contains ( const Key & key ) const

若是multihash中包含鍵爲key值爲value的項，返回true

int QMultiHash::count ( const Key & key, const T & value ) const

int QMultiHash::count ( const Key & key ) const

int QMultiHash::count () const

返回multihash中鍵爲key值爲value的鍵值對的個數

QHash<Key, T>::iterator QMultiHash::insert(const Key & key, const T & value)

插入鍵值對

int QMultiHash::remove(const Key & key, const T & value)

int QMultiHash::remove(const Key & key)

刪除鍵值對

QHash<Key, T>::iterator QMultiHash::replace ( const Key & key, const T & value )

插入鍵值對，若是有一個key的鍵值對存在，使用value替換值，若是有key多個鍵值對存在，使用value替換最近插入的鍵值對的值。

QHash<Key, T>::iterator QMultiHash::find ( const Key & key, const T & value )

查找鍵值對，返回指向鍵值對的迭代器

5、QSet

    QSet 提供了基於哈希表的鍵值對，不支持[]重載，內部使用QHash實現。

    QSet 全部成員函數是可重入的。

    QSet 主要成員函數以下：

QSet::QSet ()

QSet::QSet ( const QSet<T> & other )

構造函數

QSet<T> QSet::fromList(const QList<T> & list) [static]

返回包含list中數據的QSet對象

QSet<T> & QSet::subtract ( const QSet<T> & other )

刪除set中與other中相同的數據項，返回引用

QList<T> QSet::toList () const

將QSet轉換爲QList，QList是無序的。

4、算法類

    QT中的算法包含在<QtAlgorithms>中，<QtAlgorithms>提供了一系列通用的模板函數，用於實現容器上面的基本算法，QtAlgorithms提供的算法一般依賴於STL風格的迭代器。C++ STL也提供了不少通用算法，包含在<algorithm> 頭文件內，STL的通用算法一樣適用QT的容器類。

1、qFind()函數

InputIterator qFind(InputIterator begin, InputIterator end, const T & value)

Container::const_iterator qFind(const Container & container, const T & value)

    qFind()函數在容器中線性查找一個特定值，包括起始位置、終止位置和查找的值三個參數，若是被查找的元素存在，函數返回一個迭代器，不然則返回終止位置的迭代器。

QStringListlist;

list<<"a" <<"b"<<"c"<<"d";

QStringList::iterator i=qFind(list.begin(),list.end(),"c");

QStringList::iteratorj =qFind(list.begin(),list.end(),"e");

2、qBinaryFind()函數

RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T & value)

RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T & value, LessThan lessThan)

Container::const_iterator qBinaryFind(const Container & container, const T & value)

     qBinaryFind()是二分查找算法，只適用於查找排序以後的集合。

3、qFill()函數

void qFill(ForwardIterator begin, ForwardIterator end, const T & value)

void qFill(Container & container, const T & value)

    qFill()用特定的值填充容器。

QList<int>list(5);

qFill(list.begin(),   list.end(),10);

4、qCopy()函數

OutputIterator qCopy(InputIterator begin1, InputIterator end1, OutputIterator begin2)

    qCopy()函數能夠實現將一個容器中的元素複製到另外一個容器。

QVector<int>vect(list.count());

qCopy(list.begin(), list.end(),vect.begin());

5、qSort()函數

void qSort(RandomAccessIterator begin, RandomAccessIterator end)

void qSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan)

void qSort(Container & container)

    qSort()實現了容器元素的遞增排序，若是須要按照遞減排序，須要將 qGreater<T>()看成第三個參數傳給qSort()函數。

qSort(list.begin(), list.end(),qGreater<int>());

6、qStableSort()函數

void qStableSort(RandomAccessIterator begin, RandomAccessIterator end)

void qStableSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan)

void qStableSort(Container & container)

    qStableSort()實現穩定排序。即在排序過程當中，若是有兩個元素相等，那麼在排序結果中這兩個元素的前後順序同排序前一致。

7、qDeleteAll()函數

void qDeleteAll(ForwardIterator begin, ForwardIterator end)

void qDeleteAll(const Container & c)

    qDeleteAll()函數將對容器中存儲的全部指針進行delete操做，僅在容器元素是指針的情形下才適用。qDeleteAll()函數調用後，容器中的指針依然被存儲在容器中，須要調用clear()函數來避免指針成爲野指針。

qDeleteAll(list);

list.clear();