一、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> | ||
QLinkedList<T> | ||
QVector<T> QStack<T> | ||
QSet<T> | QSetIterator<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()。
二、顺序存储容器
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的项，返回指向插入项的迭代器
3、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链表
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
返回栈顶元素的引用
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
返回队列头元素的引用
三、关联存储容器
关联存储容器中存储的一般是二元组，即键值对。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是无序的。
四、算法类
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();
