Qt容器类

Qt提供了一组通用的基于模板的容器类，相比C++标准模板库，Qt的容器更轻量安全且更容易使用。同时在速度，内存消耗和内联代码等方面进行了优化。

Qt容器可存储的必须是可赋值的数据类型，也就是说这个类型必须有一个默认的构造函数、复制构造函数和一个赋值操作符。

这样的数据包含了通常使用的大部分类型，其中包括基本数据类型，和Qt的一些数据类型(比如QString)等，不过，Qt的QObject以及其他的子类(QWidget)等是不能存储在容器中的，但是可以通过Qt的QObject以及其他的子类的指针。

QList<QToolBar> list;   //错误
QList<QToolBar* > list;   //正确

同时Qt的容器类也是支持嵌套的

QHash<QString,QList<double> > ;   //注意最后的> >一定有个空格，否则会被认为是>> 会报错

Qt容器的两种遍历方式：JAVA型和STL型，推荐使用STL（通用且效率高）

QList类、QLinkedList类和QVector类

经常使用的容器类有QList类、QLinkedList类和QVector类等，从效率上看的话这里列出了他们三个的时间复杂度比较：

容器类	查找	插入	头部添加	尾部添加
QList	O(1)	O(n)	Amort.O(1)	Amort.O(1)
QLinkedList	O(n)	O(1)	O(1)	O(1)
QVector	O(1)	O(n)	O(n)	O(1)
Amort.O(1)表示如果仅完成一次操作，可能会有O(n)行为，但是如果是多次操作，平均结果将会是O(1)

1.QList类

QList是迄今为止最常用的容器，他的子类有：

QItemSelection
QQueue
QStringList
QTestEventList

Qt提供了可以在列表中追加的QList::append()和QList::prepend()函数，还提供两个可以插入的函数QList::insert()为了让可执行代码尽可能少，QList被高度优化了。

QList维护了一个指针数组，该数组指向QList存储的列表项的内容，因此QList是支持基于下标的快速访问的。

对于不同的数据类型，QList会采取不同的存储策略，分为以下两种:

    1.如果T是一个指针类型或者指针大小的类型，直接存在容器的数组中。
    2.如果存储对象的指针，则该指针指向实际存储的对象。
    例如：
    -------------------------------------
    #include<QDebug>
    int main(){
        QList<QString> list;   // (a)
        {
            QString str("This is a test string");
            list << str;       // (b)
        }                      // (c)
        qDebug() << list[0] << "How are you!";
        return 0;
    }
    -------------------------------------
    (a)QList<QString> list: 声明了一个QList<QString>栈对象。
    (b)list << str 通过运算符将字符串存到列表中
    (c)程序中使用花括号括起来的作用域表明，此时list保存的是一个对象的复制。

2.QLinkedList类

QLinkedList是一个链式列表，以非连续的内存块保存数据。

QLinkedList不能使用下标，只能使用迭代器，与QList相比，在对一个很大的列表进行插入操作时，QLinkedList有更高的效率。

3.QVector类

QVector在相邻的内存中存储给定数类型T的一组数值，在一个QVector的前部或者中间位置进行插入操作速度是很慢的，因为会导致内存住的大量数据移动（数组）。

QVector既可以通过下标访问，也可以通过迭代器进行访问，QVector的子类有QPolygon、QPolygonF和QStack。

4.Java风格迭代器遍历

相比STL风格迭代器遍历，JAVA更方便，但是性能消耗较大，对于每个容器类，Qt都提供两种Java风格迭代器数据类型，即只读访问和读写访问，可见下表

容器类	只读迭代器类	读写迭代器类
QList,QQueue	QListIteator	QMutableListIterator
QLinkedList	QLinkedListIteator	QMutableLinkedListIterator
QVector	QVectorIteator	QMutableVectorIterator

JAVA风格的迭代点在列表项的中间，而不是直接指向某个列表项，因此，他可能是在第一个列表项的前面，也可能在两个列表中间，或者是在最后一个列表项之后。

    QList<int> list;
    list << 1 << 2 << 3 << 4 << 5;
    QListIterator<int> it(list);
    for(;it.hasNext();)
        qDebug() << it.next();

结果为：1 2 3 4 5

上面演示的是向后遍历，向前遍历的函数有下面这几种

QListIterator::toBack(); 将迭代点移动到最后一个列表项的后面

QListIterator::hasPrevious(); 检查当前迭代点之前是否具有列表项

QListIterator::previous(); 返回前一个列表项的内容并将迭代点移动到前一个列表项之前

除此之外，QListIterator提供的其他函数有下面几种

toFront();  //移动迭代点到最前面
peekNext(); //返回下一个列表项，但是不移动迭代点
peekPrevious(); //返回前一个列表项，但是不移动迭代点
findNext();  //向后查找特定列表项，有就true没有就false，如果没有，迭代点在列表最后面
findPrevious(); //和findNext类似，如果没有，迭代点在列表最前面

QListIterator是只读迭代器，不能完成插入和删除操作，需要使用QMutableListIterator，除去QListIterator的函数，他还有insert()插入函数，remove()删除函数等。

    QList<int> list;  //空列表
    QMutableListIterator<int> it(list);  //读写迭代器
    for(int i = 0; i < 10; i++)
    {
        it.insert(i);
    }
    for(it.toFront();it.hasNext();)
    {
        qDebug() << it.next();
    }
    for(it.toBack();it.hasPrevious();)
    {
        if(it.previous() %2 == 0)
            it.remove();
        else
            it.setValue(it.peekNext() * 10);
    }
    for(it.toFront();it.hasNext();)
    {
        qDebug() << it.next();
    }

STL风格迭代器

容器类	只读迭代器类	读写迭代器类
QList,QQueue	QList::const_iterator	QList::iterator
QLinkedList	QLinkedList::const_iterator	QLinkedList::iterator
QVector	QVector::const_iterator	QVector::iterator
STL风格迭代器的API是建立在指针操作基础上的，比如++可以移动到下一项，而*可以拿到迭代器指向的值。

    QList<int> list;
    for(int j = 0; j < 10; j++)
    {
        list.insert(list.end(),j);
    }
    QList<int>::iterator i;
    for(i = list.begin(); i != list.end(); ++i)
    {
        qDebug() << (*i);
        *i = (*i) * 10;
    }
    QList<int>::const_iterator ci;
    for(ci=list.constBegin();ci!=list.constEnd();++ci)
    {
        qDebug() << *ci;
    }

QMap类和QHash类

QMap类和QHash类具有非常类的的功能，他们的差别在于：

QHash具有比QMap更加的查找速度
QHash以任意的顺序存储数据项，而QMap总是按照Key的顺序存储数据
QHash的键类型Key必须提供ioeartir==()和一个全局的qHash(Key)函数，而QMap必须提供operator<()函数。两者的复杂度

容器类	键查找	---	插入	---
---	平均	最坏	平均	最坏
QMap	O(log n)	O(log n)	O(log n)	O(log n)
QHash	Amort.O(1)	O(n)	Amort.O(1)	O(n)

QMap类

QMap<Key,T>提供了一个类型从Key的键到类型为T的值的映射。通常QMap的数据形式是一个键对应一个值，为了支持一键多值可以使用QMap<Key,T>::insertMulti()和QMap<Key,T>::values()函数。存储一键多值的数据时，也可以使用QMultiMap<Key,T> 容器，他继承于QMap。

QHash类

他与QMap的API几乎完全相同，维持着一张哈希表，大小与其存储的数据项的数目相适应。存储一键多值的数据时，也可以使用QMultiHash<Key,T> 容器，他继承于QHash。当存储的数据顺序无关紧要时，推荐使用QHash。

Java风格迭代器的两种分类

容器类	只读迭代器类	读写迭代器类
QMap<Key,T>, QMultiMap<Key,T>	QMapIterator<Key,T>	QMutableMapIterator<Key,T>
QMultiHash<Key,T>,QHash<Key,T>	QHashIterator<Key,T>	QMutableHashIterator<Key,T>

STL风格迭代器的两种分类

容器类	只读迭代器类	读写迭代器类
QMap<Key,T>, QMultiMap<Key,T>	QMap<Key,T>::const_iterator	QMap<Key,T>::iterator
QMultiHash<Key,T>,QHash<Key,T>	QHash<Key,T>::const_iterator	QHash<Key,T>::iterator

此处看一看STL的调用,JAVA参考上面List
    QMap<QString,QString> map;
    map.insert("111","aaa");
    map.insert("222","bbb");
    map.insert("333","ccc");

    QMap<QString,QString>::const_iterator cit;
    for(cit = map.constBegin();cit != map.constEnd();++cit)
    {
        qDebug() << " " << cit.key() << " " << cit.value();
    }
    QMap<QString,QString>::iterator it;
    it=map.find("111");
    if(it != map.end())
    {
        it.value() = "ddd";
    }
    QMap<QString,QString>::const_iterator ccit;
    for(ccit = map.constBegin();ccit != map.constEnd();++ccit)
    {
        qDebug() << " " << ccit.key() << " " << ccit.value();
    }

Qt常用容器类、遍历方法以及常用函数