QT开发(二十五)——QT模板库

一、QTL模板库简介

QT模板库(QT Template Library 简称QTL)是一套提供对象容器的模板。

QTL提供了对象的链表、对象的矢量(动态数组)、从一个类型到另一个类型的映射(或称为字典)和相关的迭代器和算法。容器是包含和管理其它对象的一个对象,并且提供迭代器对被包含的对象进行访问。

1QT容器类简介

    容器是能够在内存中存储其他特定类型的对象的对象,一般是通用的模板类。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所有容器类以及其他类如:QByteArrayQBrushQFontQImageQPixmap和QString都使用了隐式数据共享技术。隐式数据共享使得类在参数和返回值中使用传值方式相当高效。

    为了正确使用隐式数据共享,需要建立一个良好的编程习惯。首先,对list或者vector使用at()函数而不是[]操作符进行只读访问。 原因是[]操作符既可以是左值又可以是右值,这让Qt容器很难判断到底是左值还是右值,而at()函数是不能作为左值的,因此可以进行隐式数据共享。其次,对于begin()end()以及其他一些非const容器,在数据改变时QT会进行深复制,要尽可能使用const_iterator, constBegin()和constEnd()

二、顺序存储容器

1QVector

    QVector类是一个提供动态数组的模板类。QVector<T>使用连续内存来保存数据项,分配所需内存的方式与动态内存分配的方式相比,减少了在时间和内存上的开销。

wKiom1grCEnzVWohAAHDZBoemAQ418.png

    QVector<T>和其他QT容器、大部分值类型的类(包括 QString)一样,使用隐式共享。但拷贝一个QVector时,内部只是拷贝了一个指针和递增了引用计数,只有修改数据时,才会进行深拷贝,隐式共享也称写时复制。

    隐式共享是QVectorstd::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

QVectorQList转换函数

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

std::vector<T> toStdVector() const

QVectorstd::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个元素

2QLinekedList

    QLinkedList<T>提供一个双向链表,插入删除操作在常数时间完成。

wKioL1grCHWj0GnyAAP3v3bgkTA768.png

    虽然插入、删除操作是常数时间,但 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

QLinkedListstd::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的项,返回指向插入项的迭代器

3、QList

    QList是典型的数组链表,不是真正意义上的链表。

    根据参数T的不同, QList 有两种组织方式。通常情况下, QList 有一个指针数组用于保存用new操作符在堆上分配的对象的指针,使得在容器的中间插入和删除的速度比参数为不可拷贝类型的QVector快,因为指针是可以用内存拷贝。

wKiom1grCJ_g8oz8AADo4a8GhA8857.png

    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]

QSetstd::listQVector类型转换为QList

QSet<T> QList::toSet() const

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

QVector<T> QList::toVector() const

QList转换为QSetstd::listQVector

void QList::append(const T & value)

list尾部插入值为value的元素

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

list尾部插入value链表

4、 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

返回栈顶元素的引用

 

5QQueue

    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

返回队列头元素的引用

三、关联存储容器

    关联存储容器中存储的一般是二元组,即键值对。QT提供两种关联容器类型:QMap<K, T>和QHash<K, T>。

1QMap

 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的链表

2QMultiMap

    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的键值对

3QHash

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的元素的值的链表

4QMultiHash

    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 )

查找键值对,返回指向键值对的迭代器

5QSet

    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是无序的。

四、算法类

    QT中的算法包含在<QtAlgorithms>中,<QtAlgorithms>提供了一系列通用的模板函数,用于实现容器上面的基本算法QtAlgorithms提供的算法通常依赖于STL风格的迭代器。C++ STL也提供了很多通用算法,包含在<algorithm> 头文件内STL的通用算法同样适用QT的容器类。

1qFind()函数

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");

2qBinaryFind()函数

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()是二分查找算法,只适用于查找排序之后的集合。

3qFill()函数

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);

4qCopy()函数

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

    qCopy()函数可以实现将一个容器中的元素复制到另一个容器。

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

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

5qSort()函数

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>());

6qStableSort()函数

void qStableSort(RandomAccessIterator begin, RandomAccessIterator end)

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

void qStableSort(Container & container)

    qStableSort()实现稳定排序。即在排序过程中,如果有两个元素相等,那么在排序结果中这两个元素的先后顺序同排序前一致。

7qDeleteAll()函数

void qDeleteAll(ForwardIterator begin, ForwardIterator end)

void qDeleteAll(const Container & c)

    qDeleteAll()函数将对容器中存储的所有指针进行delete操作,仅在容器元素是指针的情形下才适用。qDeleteAll()函数调用后,容器中的指针依然被存储在容器中,需要调用clear()函数来避免指针成为野指针。

qDeleteAll(list);

list.clear();