Qt容器类汇总说明

版权声明：若无来源注明，Techie亮博客文章均为原创。转载请以链接形式标明本文标题和地址：
本文标题：Qt容器类汇总说明本文地址：http://techieliang.com/2017/12/542/

文章目录

下述说明来源于官方文档

1. 介绍

Qt库提供了一组通用的基于模板的容器类。这些类可用于存储指定类型的项。例如，如果你需要一个可调整大小的数组qstrings，使用QVector <QString>。

这些容器类的设计要比STL容器更轻、更安全、更容易使用。如果您不熟悉STL，或者更喜欢做“qt方式”，您可以使用这些类而不是STL类。

Qt还提供了一个foreach关键字，让它来遍历所有的物品存放在一个容器很容易。

qt提供的foreach在c++标准中并没有，在c++11中提供了类似于for(auto t:container)方式遍历容器，此方式qt也支持，个人感觉使用for更好

……更多介绍看官网

2. 本博客的Qt容器使用说明

QMap、QMultiMap、(当前内容截止此随笔发布日，后续内容请见博客后续更新本文地址：http://techieliang.com/2017/12/542/)

3. 容器类

Qt提供了下列顺序容器：QList，QLinkedList，QVector，QStack，和QQueue。对于大多数应用程序，QList是使用最好的类型。虽然它底层用数组链表实现，但提供了非常快速的前后追加函数。如果你真的需要一个链表，用QLinkedList；如果你想让你的项目占用连续的内存位置，使用QVector。QStack 和QQueue提供了先进先出(LIFO )，先结后出（FIFO ）。

Qt也提供了关联式容器：?QMap,?QMultiMap,?QHash,?QMultiHash,和QSet.?。Multi容器支持多个value关联到单一的key。Hash容器提供了通过hash函数快速查找取代二分查找。

特殊情况下，?QCache?和?QContiguousCache?提供了在有限的cache?中高效的查找对象。

Class	Summary
QList<T>	This is by far the most commonly used container class. It stores a list of values of a given type (T) that can be accessed by index. Internally, the QList is implemented using an array, ensuring that index-based access is very fast.Items can be added at either end of the list using QList::append() and QList::prepend(), or they can be inserted in the middle using QList::insert(). More than any other container class, QList is highly optimized to expand to as little code as possible in the executable. QStringList inherits from QList<QString>.
QLinkedList<T>	This is similar to QList, except that it uses iterators rather than integer indexes to access items. It also provides better performance than QList when inserting in the middle of a huge list, and it has nicer iterator semantics. (Iterators pointing to an item in a QLinkedList remain valid as long as the item exists, whereas iterators to a QList can become invalid after any insertion or removal.)
QVector<T>	This stores an array of values of a given type at adjacent positions in memory. Inserting at the front or in the middle of a vector can be quite slow, because it can lead to large numbers of items having to be moved by one position in memory.
QStack<T>	This is a convenience subclass of QVector that provides “last in, first out” (LIFO) semantics. It adds the following functions to those already present in QVector: push(), pop(), and top().
QQueue<T>	This is a convenience subclass of QList that provides “first in, first out” (FIFO) semantics. It adds the following functions to those already present in QList: enqueue(), dequeue(), and head().
QSet<T>	This provides a single-valued mathematical set with fast lookups.
QMap<Key, T>	This provides a dictionary (associative array) that maps keys of type Key to values of type T. Normally each key is associated with a single value. QMap stores its data in Key order; if order doesn’t matter QHash is a faster alternative.
QMultiMap<Key, T>	This is a convenience subclass of QMap that provides a nice interface for multi-valued maps, i.e. maps where one key can be associated with multiple values.
QHash<Key, T>	This has almost the same API as QMap, but provides significantly faster lookups. QHash stores its data in an arbitrary order.
QMultiHash<Key, T>	This is a convenience subclass of QHash that provides a nice interface for multi-valued hashes.

4. 迭代器类

Qt提供了多种风格的迭代器，Java风格和stl风格

4.1. 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>

4.2. STL风格迭代器

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

5. Qt提供的其他容器

Qt includes three template classes that resemble containers in some
respects. These classes don’t provide iterators and cannot be used with
the foreach keyword.

QVarLengthArray<T, Prealloc> provides a low-level variable-length array. It can be used instead of QVector in places where speed is particularly important.
QCache<Key, T> provides a cache to store objects of a certain type T associated with keys of type Key.
QContiguousCache<T> provides an efficient way of caching data that is typically accessed in a contiguous way.
QPair<T1, T2> stores a pair of elements.

Additional non-template types that compete with Qt’s template containers are QBitArray, QByteArray, QString, and QStringList.

6. Qt容器算法复杂性

Algorithmic complexity is concerned about how fast (or slow) each
function is as the number of items in the container grow. For example,
inserting an item in the middle of a QLinkedList is an extremely fast operation, irrespective of the number of items stored in the QLinkedList. On the other hand, inserting an item in the middle of a QVector is potentially very expensive if the QVector contains many items, since half of the items must be moved one position in memory.

To describe algorithmic complexity, we use the following terminology, based on the “big Oh” notation:

Constant time: O(1). A function is said to run in constant
time if it requires the same amount of time no matter how many items are
present in the container. One example is QLinkedList::insert().
Logarithmic time: O(log n). A function that runs in
logarithmic time is a function whose running time is proportional to the
logarithm of the number of items in the container. One example is
qBinaryFind().
Linear time: O(n). A function that runs in linear time
will execute in a time directly proportional to the number of items
stored in the container. One example is QVector::insert().
Linear-logarithmic time: O(n log n). A function
that runs in linear-logarithmic time is asymptotically slower than a
linear-time function, but faster than a quadratic-time function.
Quadratic time: O(n?). A quadratic-time function
executes in a time that is proportional to the square of the number of
items stored in the container.

The following table summarizes the algorithmic complexity of Qt’s sequential container classes:

	Index lookup	Insertion	Prepending	Appending
QLinkedList<T>	O(n)	O(1)	O(1)	O(1)
QList<T>	O(1)	O(n)	Amort. O(1)	Amort. O(1)
QVector<T>	O(1)	O(n)	O(n)	Amort. O(1)

In the table, “Amort.” stands for “amortized behavior”. For example,
“Amort. O(1)” means that if you call the function only once, you might
get O(n) behavior, but if you call it multiple times (e.g., n times), the average behavior will be O(1).

The following table summarizes the algorithmic complexity of Qt’s associative containers and sets:

	Key lookup		Insertion
	Average	Worst case	Average	Worst case
QMap<Key, T>	O(log n)	O(log n)	O(log n)	O(log n)
QMultiMap<Key, T>	O(log n)	O(log n)	O(log n)	O(log n)
QHash<Key, T>	Amort. O(1)	O(n)	Amort. O(1)	O(n)
QSet<Key>	Amort. O(1)	O(n)	Amort. O(1)	O(n)