QT开发（二十五）——QT模板库

QT开发（二十五）——QT模板库

一、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 QQueue	QListIterator	QMutableListIterator
QLinkedList	QLinkedListIterator	QMutableLinkedListIterator
QVector QStack	QVectorIterator	QMutableVectorIterator
QSet	QSetIterator	QMutableSetIterator
QMap QMultiMap	QMapIterator	QMutableMapIterator
QHash QMultiHash	QHashIterator	QMutableHashIterator

    Java风格迭代器不指向任何元素，而是指向第一个元素之前、两个元素之间或者是最后一个元素之后的位置。

QList list;

// ...

QListIterator i(list);

while (i.hasNext()) {

        doSomethingWith(i.next());

}

STL风格迭代器

C::iterator和C::const_iterator。

Containers	Read-only iterator	Read-write iterator
QList QQueue	QList::const_iterator	QList::iterator
QLinkedList	QLinkedList::const_iterator	QLinkedList::iterator
QVector QStack	QVector::const_iterator	QVector::iterator
QSet	QSet::const_iterator	QSet::iterator
QMap QMultiMap	QMap::const_iterator	QMap::iterator
QHash QMultiHash	QHash::const_iterator	QHash::iterator

    STL风格迭代器begin()函数返回指向第一个元素的STL风格的遍历器，而end()函数则会返回指向最后一个元素之后位置的STL风格的遍历器。

QList::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使用连续内存来保存数据项，分配所需内存的方式与动态内存分配的方式相比，减少了在时间和内存上的开销。

650) this.width=650;" src="http://s2.51cto.com/wyfs02/M01/8A/3B/wKiom1grCEnzVWohAAHDZBoemAQ418.png" title="图片1.png" alt="wKiom1grCEnzVWohAAHDZBoemAQ418.png" />

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

    隐式共享是QVector和std::vector的主要区别。

    QBasicAtomic类用于保存引用计数，支持原子操作（线程安全），确保隐式共享可以跨线程使用。 QT在不同架构下使用汇编语言来实现QBasicAtomic类。

    为了避免每次容器增长时都分配内存， QVector 会一次分配超过需要的内存。如果参数T是可拷贝类型（可以通过memcpy() or memmove()进行拷贝的对象，例如C++原类型和QT隐式共享类）， QVector使用 realloc()一次再分配 4096字节的增量。 这是因为现代操作系统当重新分配一个内存时并不拷贝整块数据，只是物理内存页面简单的重新排序，第一页和最后一页需要进行拷贝。

    对于不可拷贝数据类型，QVector以每次增长50%的方式，确保在频繁调用append()函数时平均算法复杂度为 O(n)。

    如果用QVector储存自定义的类型， QT会假定自定义数据类型是不可拷贝类型。对于自定义可拷贝的数据类型，可以使用 Q_DECLARE_TYPEINFO()宏来声明。

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

    Q_DECLARE_TYPEINFO()宏也可用于其他容器，最典型的就是 QList。如果自定义数据类型是没有定义构造函数和析构函数的POD类型，能够用memcpy 和memmove函数进行拷贝，可以用把自定义类型声明为元类型而不是可拷贝类型。

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

    如果T是元类型， QVector不会调用构造函数和析构函数，对可拷贝类型的优化对元类型都有效。

    QVector提供了[]的重载，但对于只读操作，由于不需要深拷贝，使用at（）函数的效率会较高。

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

    如果实现不知道vector的长度，可以创建一个空参数的vector，然后使用append()函数添加数据：

QVector v;
 v.append(1.1);
 v.append(1.2);

    QVector重载了<<，可以直接使用<<操作符

QVector v;
 v << 1.1 << 1.2;

    如果QVector中的数据没有被显式地赋值，那么，数据项将使用加入类的默认构造函数进行初始化，如果是基本数据类型和指针，则初始化为0

    QVector类的所有成员函数是可重入的。

    QVector主要成员函数如下：

QVector()

QVector(int size)

QVector(int size, const T & value)

QVector(const QVector & other)

构造函数

QVector fromList(const QList & list)[static]

QList toList() const

QVector与QList转换函数

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

std::vector 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提供一个双向链表，插入删除操作在常数时间完成。

650) this.width=650;" src="http://s1.51cto.com/wyfs02/M01/8A/37/wKioL1grCHWj0GnyAAP3v3bgkTA768.png" title="图片2.png" alt="wKioL1grCHWj0GnyAAP3v3bgkTA768.png" />

    虽然插入、删除操作是常数时间，但 QLinkedList只有在对象数量超过200对象时才能看出优势。对于小于200个对象的链表， QList提供更好的性能、耗费更小的内存。

    QLinkedList的优点是数据的插入和删除很快，但是随机位置值的访问会很慢。与QVector不同，QLinkedList并没有提供重载的[]操作符，只能使用append()函数，或者<<操作符进行数据的添加。

    QLinkedList所有成员函数是可重入的。

    QLinkedList主要成员函数如下：

QLinkedList::QLinkedList ()

QLinkedList::QLinkedList ( const QLinkedList & other )

构造函数

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

std::list 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快，因为指针是可以用内存拷贝。

650) this.width=650;" src="http://s3.51cto.com/wyfs02/M02/8A/3B/wKiom1grCJ_g8oz8AADo4a8GhA8857.png" title="图片3.png" alt="wKiom1grCJ_g8oz8AADo4a8GhA8857.png" />

    QList是一个同时拥有QVector和QLinkedList的大多数有点的顺序存储容器类。既可以像QVector一样支持快速的随机访问，重载了[]操作符，提供了索引访问的方式；也可以像 QLinkedList一样，支持快速的添加、删除操作。除非我们需要进行在很大的集合的中间位置的添加、删除操作，或者是需要所有元素在内存中必须连续存储，否则我们应该一直使用Qlist。

    为了确保下标访问速度，QList内部使用数组实现。

    QList有几个特殊的情况。一个是QStringList，这是 QList的子类，提供针对QString的很多特殊操作。QStack和 QQueue分别实现了数据结构中的堆栈和队列，前者具有push(), pop(), top()函数，后者具有enqueue(), dequeue(), head()函数。

    QList所有成员函数是可重入的。

    QList主要成员函数如下：

QList::QList ()

QList::QList(const QList & other)

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

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

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

QSet、std::list、QVector类型转换为QList

QSet QList::toSet() const

std::list QList::toStdList() const

QVector QList::toVector() const

QList转换为QSet、std::list、QVector

void QList::append(const T & value)

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

void QList::append(const QList & 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和QHash。

1、QMap

 QMap是一个以升序键顺序存储键值对的数据结构，QMap原型为QMap模板。

QMap保存一个根据主键排序的链表（主键，值），提供 O(log n)的查找时间常数。 QMap内部使用的是一个跳表的数据结构， 与红黑树提供类似的算法复杂度和性能。早期版本的 QMap 用的是红黑树，但是跳表代码简洁、节省内存。

class QMap,QMap中的键值对根据Key进行了排序，QMap中Key类型必须重载operator<。

QMap使用方法如下：

 

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

    QMap使用注意：

通过Key获取value时：

    Key存在时返回对应的value

    Key不存在时返回值类型所对应的“零”值

插入键值对时：

    key存在时更新value的值

    Key不存在时插入新的键值对

    QMap是一种键-值对的数据结构，实际上使用跳表skip-list实现，按照K进行升序的方式进行存储。使用QMap的insert()函数可以向QMap中插入数据。

QMap map;

map.insert("eins", 1);

map.insert("sieben", 7);

map.insert("dreiundzwanzig", 23);

QMap也重载了[]运算符，可以按照数组的赋值方式进行使用

map["eins"] = 1;

map["sieben"] = 7;

map["dreiundzwanzig"] = 23;

    []操作符同样也可以像数组一样取值。如果在一个非const的map中，使用[]操作符取一个不存在的Key的值，则这个Key会被自动创建，并将其关联的value赋予一个空值。如果要避免这种情况，请使用QMap的value()函数：

    QMap中的K和T可以是基本数据类型，如int，double，可以是指针，或者是拥有默认构造函数、拷贝构造函数和赋值运算符的类。并且K必须要重载<运算符，因为QMap需要按K升序进行排序。

    QMap提供了keys()和values()函数，可以获得键的集合和值的集合。这两个集合都是使用QList作为返回值的。

    QMap所有成员函数是可重入的。

QMap主要成员函数如下：

QMap::QMap ()

QMap::QMap ( const QMap & other )

QMap::QMap ( const std::map & other )

构造函数

std::map QMap::toStdMap () const

QMap转换为std::map

QList QMap::uniqueKeys () const

返回map中所有唯一的key的链表

2、QMultiMap

    QMultiMap继承自QMap，允许一个key索引多个value。

    QMap所有成员函数是可重入的。

QMap主要的成员函数如下：

QMultiMap::QMultiMap ()

QMultiMap::QMultiMap ( const QMap & other )

构造函数

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

QMap::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。

QHash中的键值对在内部无序排列，key类型必须重载operator==,key对象必须重载全局哈希函数qHash（）。

QHash使用方法如下：

   

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

    QHash是使用散列存储的键-值对，QHash接口同QMap基本一样，但实现需求不同。QHash的查找速度比QMap快很多，并且存储是不排序的。对于QHash而言，K的类型必须重载了==操作符，并且必须被全局函数qHash()所支持，qHash()函数用于返回key的散列值。QT已经为int、指针、 QChar、QString和QByteArray实现了qHash()函数。

    QHash会自动地为散列分配一个初始大小，并且在插入数据或者删除数据的时候改变散列的大小。我们可以使用reserve()函数扩大散列，使用 squeeze()函数将散列缩小到最小大小(这个最小大小实际上是能够存储这些数据的最小空间)。在使用时，我们可以使用reserve()函数将数据 项扩大到我们所期望的最大值，然后插入数据，完成之后使用squeeze()函数收缩空间。

    QHash同样也是单值类型的，可以使用insertMulti()函数或者QMultiHash类来为一个键插入多个值。另外，除了QHash，Qt也提供了QCache来提供缓存，QSet用于仅存储key的情况。这两个类同QHash一样具有K的类型限制。

    QHash所有成员函数是可重入的。

QHash主要成员函数如下：

QHash::QHash ()

QHash::QHash ( const QHash & other )

构造函数

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

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

返回hash中value的key

QList QHash::keys () const

返回hash中所有的key的链表

QList QHash::keys ( const T & value ) const

返回hash中包含value的所有key的链表

QList 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 QHash::values () const

返回hash中所有的值的链表

QList 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 & other)

构造函数

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

QHash::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::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::iterator QMultiHash::replace ( const Key & key, const T & value )

插入键值对，如果有一个key的键值对存在，使用value替换值，如果有key多个键值对存在，使用value替换最近插入的键值对的值。

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

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

5、QSet

    QSet 提供了基于哈希表的键值对，不支持[]重载，内部使用QHash实现。

    QSet 所有成员函数是可重入的。

    QSet 主要成员函数如下：

QSet::QSet ()

QSet::QSet ( const QSet & other )

构造函数

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

返回包含list中数据的QSet对象

QSet & QSet::subtract ( const QSet & other )

删除set中与other中相同的数据项，返回引用

QList QSet::toList () const

将QSet转换为QList，QList是无序的。

四、算法类

    QT中的算法包含在中，提供了一系列通用的模板函数，用于实现容器上面的基本算法，QtAlgorithms提供的算法通常依赖于STL风格的迭代器。C++ STL也提供了很多通用算法，包含在 头文件内，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()用特定的值填充容器。

QListlist(5);

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

4、qCopy()函数

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

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

QVectorvect(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()当作第三个参数传给qSort()函数。

qSort(list.begin(), list.end(),qGreater());

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

本文出自 “生命不息，奋斗不止” 博客，谢绝转载！