容器类

介绍

Qt 库提供一组基于模板的一般目的容器类。这些类可以用于存储指定类型项。例如，若需要可重置尺寸数组的 QString ，使用 QList < QString >.

这些容器类被设计得比 STL 容器更轻、更安全且更易于使用。若不熟悉 STL，或偏好以 Qt 方式做事情，可以使用这些类而不是 STL 类。

容器类隐式共享，它们可重入，且它们有优化针对速度、低内存消耗及最小内联代码扩展，结果是更小可执行文件。此外，它们是 thread-safe 在所有用于访问它们的线程将其用作只读容器的状况下。

容器提供用于遍历的迭代器。 STL 样式迭代器是最高效的一种，且可以使用同 Qt 和 STL 的一般算法 . Java 风格迭代器向后提供兼容性。

注意： 从 Qt 5.14 起，范围构造函数可用于大多数容器类。 QMultiMap 是明显例外。鼓励使用它们，以替换 Qt 5 中的各种已弃用 from/to 方法。例如：

QList<int> list = {1, 2, 3, 4, 4, 5};
QSet<int> set(list.cbegin(), list.cend());
/*
    Will generate a QSet containing 1, 2, 3, 4, 5.
*/

容器类

Qt 提供以下顺序容器： QList , QStack ，和 QQueue 。对于大多数应用程序， QList 是最优使用类型。它提供非常快速的追加。若确实需链表，使用 std::list。 QStack and QQueue 是提供 LIFO (后进先出) 和 FIFO (先进先出) 语义的方便类。

Qt 还提供这些关联容器： QMap , QMultiMap , QHash , QMultiHash ，和 QSet . The "Multi" containers conveniently support multiple values associated with a single key. The "Hash" containers provide faster lookup by using a hash function instead of a binary search on a sorted set.

作为特殊情况， QCache and QContiguousCache 类以有限缓存存储，为对象提供高效哈希查找。

类	摘要
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, it stores an array of values of a given type at adjacent positions in memory. Inserting at the front or in the middle of a list can be quite slow, because it can lead to large numbers of items having to be moved by one position in memory.
QVarLengthArray <T, Prealloc>	This provides a low-level variable-length array. It can be used instead of QList in places where speed is particularly important.
QStack <T>	这是方便子类化的 QList that provides "last in, first out" (LIFO) semantics. It adds the following functions to those already present in QList : push (), pop ()，和 top ().
QQueue <T>	这是方便子类化的 QList that provides "first in, first out" (FIFO) semantics. It adds the following functions to those already present in QList : enqueue (), dequeue ()，和 head ().
QSet <T>	这提供带有快速查找的单值数学集。
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>	这是方便子类化的 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>	这是方便子类化的 QHash that provides a nice interface for multi-valued hashes.

容器可以嵌套。例如，完全可能使用 QMap < QString , QList <int>>，其中键类型为 QString 和值类型 QList <int>.

The containers are defined in individual header files with the same name as the container (e.g., <QList> )。为方便起见，容器的向前声明在 <QtContainerFwd> .

The values stored in the various containers can be of any 可赋值数据类型 . To qualify, a type must provide a copy constructor, and an assignment operator. For some operations a default constructor is also required. This covers most data types you are likely to want to store in a container, including basic types such as int and double , pointer types, and Qt data types such as QString , QDate ，和 QTime , but it doesn't cover QObject 或任何 QObject 子类 ( QWidget , QDialog , QTimer , etc.). If you attempt to instantiate a QList < QWidget >, the compiler will complain that QWidget 's copy constructor and assignment operators are disabled. If you want to store these kinds of objects in a container, store them as pointers, for example as QList < QWidget *>.

Here's an example custom data type that meets the requirement of an assignable data type:

class Employee
{
public:
    Employee() {}
    Employee(const Employee &other);
    Employee &operator=(const Employee &other);
private:
    QString myName;
    QDate myDateOfBirth;
};

If we don't provide a copy constructor or an assignment operator, C++ provides a default implementation that performs a member-by-member copy. In the example above, that would have been sufficient. Also, if you don't provide any constructors, C++ provides a default constructor that initializes its member using default constructors. Although it doesn't provide any explicit constructors or assignment operator, the following data type can be stored in a container:

struct Movie
{
    int id;
    QString title;
    QDate releaseDate;
};

Some containers have additional requirements for the data types they can store. For example, the Key type of a QMap <Key, T> 必须提供 operator<() . Such special requirements are documented in a class's detailed description. In some cases, specific functions have special requirements; these are described on a per-function basis. The compiler will always emit an error if a requirement isn't met.

Qt's containers provide operator<<() and operator>>() so that they can easily be read and written using a QDataStream . This means that the data types stored in the container must also support operator<<() and operator>>(). Providing such support is straightforward; here's how we could do it for the Movie struct above:

QDataStream &operator<<(QDataStream &out, const Movie &movie)
{
    out << (quint32)movie.id << movie.title
        << movie.releaseDate;
    return out;
}
QDataStream &operator>>(QDataStream &in, Movie &movie)
{
    quint32 id;
    QDate date;
    in >> id >> movie.title >> date;
    movie.id = (int)id;
    movie.releaseDate = date;
    return in;
}

The documentation of certain container class functions refer to default-constructed values ; for example, QList automatically initializes its items with default-constructed values, and QMap::value () returns a default-constructed value if the specified key isn't in the map. For most value types, this simply means that a value is created using the default constructor (e.g. an empty string for QString ). But for primitive types like int and double , as well as for pointer types, the C++ language doesn't specify any initialization; in those cases, Qt's containers automatically initialize the value to 0.

遍历容器

基于范围 for

基于范围 for should preferably be used for containers:

QList<QString> list = {"A", "B", "C", "D"};
for (const auto &item : list) {
   ...
}

Note that when using a Qt container in a non-const context, 隐式共享 may perform an undesired detach of the container. To prevent this, use std::as_const() :

QList<QString> list = {"A", "B", "C", "D"};
for (const auto &item : std::as_const(list)) {
    ...
}

For associative containers, this will loop over the values.

基于索引

For sequential containers that store their items contiguously in memory (for example, QList ), index-based iteration can be used:

QList<QString> list = {"A", "B", "C", "D"};
for (qsizetype i = 0; i < list.size(); ++i) {
    const auto &item = list.at(i);
    ...
}

迭代器类

Iterators provide a uniform means to access items in a container. Qt's container classes provide two types of iterators: STL-style iterators and Java-style iterators. Iterators of both types are invalidated when the data in the container is modified or detached from 隐式共享副本 due to a call to a non-const member function.

STL 样式迭代器

STL-style iterators have been available since the release of Qt 2.0. They are compatible with Qt's and STL's 一般算法 and are optimized for speed.

For each container class, there are two STL-style iterator types: one that provides read-only access and one that provides read-write access. Read-only iterators should be used wherever possible because they are faster than read-write iterators.

容器	只读迭代器	读写迭代器
QList <T>, QStack <T>, QQueue <T>	QList <T>::const_iterator	QList <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

The API of the STL iterators is modelled on pointers in an array. For example, the ++ operator advances the iterator to the next item, and the * operator returns the item that the iterator points to. In fact, for QList and QStack , which store their items at adjacent memory positions, the iterator type is just a typedef for T * ，和 const_iterator type is just a typedef for const T * .

In this discussion, we will concentrate on QList and QMap . The iterator types for QSet have exactly the same interface as QList 's iterators; similarly, the iterator types for QHash have the same interface as QMap 's iterators.

Here's a typical loop for iterating through all the elements of a QList < QString > in order and converting them to lowercase:

QList<QString> list = {"A", "B", "C", "D"};
for (auto i = list.begin(), end = list.end(); i != end; ++i)
    *i = (*i).toLower();

STL-style iterators point directly at items. The begin () function of a container returns an iterator that points to the first item in the container. The end () function of a container returns an iterator to the imaginary item one position past the last item in the container. end () marks an invalid position; it must never be dereferenced. It is typically used in a loop's break condition. If the list is empty, begin () 等于 end (), so we never execute the loop.

The diagram below shows the valid iterator positions as red arrows for a list containing four items:

Iterating backward with an STL-style iterator is done with reverse iterators:

QList<QString> list = {"A", "B", "C", "D"};
for (auto i = list.rbegin(), rend = list.rend(); i != rend; ++i)
    *i = i->toLower();

In the code snippets so far, we used the unary * operator to retrieve the item (of type QString ) stored at a certain iterator position, and we then called QString::toLower () on it.

For read-only access, you can use const_iterator, cbegin ()，和 cend ()。例如：

for (auto i = list.cbegin(), end = list.cend(); i != end; ++i)
    qDebug() << *i;

The following table summarizes the STL-style iterators' API:

表达式	行为
`*i`	返回当前项
`++i`	将迭代器推进到下一项
`i += n`	Advances the iterator by `n` 项
`--i`	Moves the iterator back by one item
`i -= n`	Moves the iterator back by `n` 项
`i - j`	Returns the number of items between iterators `i` and `j`

The ++ and -- operators are available both as prefix ( ++i , --i ) and postfix ( i++ , i-- ) operators. The prefix versions modify the iterators and return a reference to the modified iterator; the postfix versions take a copy of the iterator before they modify it, and return that copy. In expressions where the return value is ignored, we recommend that you use the prefix operators ( ++i , --i ), as these are slightly faster.

For non-const iterator types, the return value of the unary * operator can be used on the left side of the assignment operator.

For QMap and QHash ， * operator returns the value component of an item. If you want to retrieve the key, call key() on the iterator. For symmetry, the iterator types also provide a value() function to retrieve the value. For example, here's how we would print all items in a QMap to the console:

QMap<int, int> map;
...
for (auto i = map.cbegin(), end = map.cend(); i != end; ++i)
    qDebug() << i.key() << ':' << i.value();

Thanks to 隐式共享 , it is very inexpensive for a function to return a container per value. The Qt API contains dozens of functions that return a QList or QStringList per value (e.g., QSplitter::sizes ()). If you want to iterate over these using an STL iterator, you should always take a copy of the container and iterate over the copy. For example:

// RIGHT
const QList<int> sizes = splitter->sizes();
for (auto i = sizes.begin(), end = sizes.end(); i != end; ++i)
    ...
// WRONG
for (auto i = splitter->sizes().begin();
        i != splitter->sizes().end(); ++i)
    ...

This problem doesn't occur with functions that return a const or non-const reference to a container.

隐式共享 has another consequence on STL-style iterators: you should avoid copying a container while iterators are active on that container. The iterators point to an internal structure, and if you copy a container you should be very careful with your iterators. E.g:

QList<int> a, b;
a.resize(100000); // make a big list filled with 0.
QList<int>::iterator i = a.begin();
// WRONG way of using the iterator i:
b = a;
/*
    Now we should be careful with iterator i since it will point to shared data
    If we do *i = 4 then we would change the shared instance (both vectors)
    The behavior differs from STL containers. Avoid doing such things in Qt.
*/
a[0] = 5;
/*
    Container a is now detached from the shared data,
    and even though i was an iterator from the container a, it now works as an iterator in b.
    Here the situation is that (*i) == 0.
*/
b.clear(); // Now the iterator i is completely invalid.
int j = *i; // Undefined behavior!
/*
    The data from b (which i pointed to) is gone.
    This would be well-defined with STL containers (and (*i) == 5),
    but with QList this is likely to crash.
*/

The above example only shows a problem with QList , but the problem exists for all the implicitly shared Qt containers.

Java 风格迭代器

Java 风格迭代器 were introduced in Qt 4. Their API is modelled on Java's iterator classes. New code should should prefer STL 样式迭代器 .

Qt 容器相较 std 容器

Qt 容器	最接近的标准容器
QList <T>	类似于 std::vector<T> QList and QVector were unified in Qt 6. Both use the datamodel from QVector . QVector is now an alias to QList . This means that QList is not implemented as a linked list, so if you need constant time insert, delete, append or prepend, consider `std::list<T>` 。见 QList 了解细节。
QVarLengthArray <T, Prealloc>	Resembles a mix of std::array<T> and std::vector<T>. For performance reasons, QVarLengthArray lives on the stack unless resized. Resizing it automatically causes it to use the heap instead.
QStack <T>	Similar to std::stack<T>, inherits from QList .
QQueue <T>	Similar to std::queue<T>, inherits from QList .
QSet <T>	Similar to std::unordered_set<T>. Internally, QSet is implemented with a QHash .
QMap <Key, T>	类似于 std::map<T>。
QMultiMap <Key, T>	Similar to std::multimap<T>.
QHash <Key, T>	Most similar to std::unordered_map<T>.
QMultiHash <Key, T>	Most similar to std::unordered_multimap<T>.

Qt 容器和 std 算法

可以使用 Qt 容器采用函数从 #include <algorithm> .

QList<int> list = {2, 3, 1};
std::sort(list.begin(), list.end());
/*
    Sort the list, now contains { 1, 2, 3 }
*/
std::reverse(list.begin(), list.end());
/*
    Reverse the list, now contains { 3, 2, 1 }
*/
int even_elements =
        std::count_if(list.begin(), list.end(), [](int element) { return (element % 2 == 0); });
/*
    Count how many elements that are even numbers, 1
*/

其它类似容器的类

Qt includes other template classes that resemble containers in some respects. These classes don't provide iterators and cannot be used with the foreach 关键词。

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.

Additional non-template types that compete with Qt's template containers are QBitArray , QByteArray , QString ，和 QStringList .

算法的复杂性

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 std::list is an extremely fast operation, irrespective of the number of items stored in the list. On the other hand, inserting an item in the middle of a QList is potentially very expensive if the QList 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 QList::push_back ().
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 the binary search algorithm.
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 QList::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 the sequential container QList <T>:

	索引查找	插入	前置	追加
QList <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:

	键查找		插入
	平均	最坏情况	平均	最坏情况
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 )

采用 QList , QHash ，和 QSet , the performance of appending items is amortized O(log n ). It can be brought down to O(1) by calling QList::reserve (), QHash::reserve ()，或 QSet::reserve () with the expected number of items before you insert the items. The next section discusses this topic in more depth.

原语和可重定位类型的优化

Qt containers can use optimized code paths if the stored elements are relocatable or even primitive. However, whether types are primitive or relocatable cannot be detected in all cases. You can declare your types to be primitive or relocatable by using the Q_DECLARE_TYPEINFO macro with the Q_PRIMITIVE_TYPE flag or the Q_RELOCATABLE_TYPE flag. See the documentation of Q_DECLARE_TYPEINFO for further details and usage examples.

若不使用 Q_DECLARE_TYPEINFO ，Qt 将使用 std::is_trivial_v<T> to identify primitive types and it will require both std::is_trivially_copyable_v<T> and std::is_trivially_destructible_v<T> to identify relocatable types. This is always a safe choice, albeit of maybe suboptimal performance.

增长战略

QList <T>, QString ，和 QByteArray store their items contiguously in memory; QHash <Key, T> keeps a hash table whose size is proportional to the number of items in the hash. To avoid reallocating the data every single time an item is added at the end of the container, these classes typically allocate more memory than necessary.

Consider the following code, which builds a QString from another QString :

QString onlyLetters(const QString &in)
{
    QString out;
    for (qsizetype j = 0; j < in.size(); ++j) {
        if (in.at(j).isLetter())
            out += in.at(j);
    }
    return out;
}

构建字符串 out dynamically by appending one character to it at a time. Let's assume that we append 15000 characters to the QString string. Then the following 11 reallocations (out of a possible 15000) occur when QString runs out of space: 8, 24, 56, 120, 248, 504, 1016, 2040, 4088, 8184, 16376. At the end, the QString has 16376 Unicode characters allocated, 15000 of which are occupied.

The values above may seem a bit strange, but there is a guiding principle. It advances by doubling the size each time. More precisely, it advances to the next power of two, minus 16 bytes. 16 bytes corresponds to eight characters, as QString 使用 UTF-16 在内部。

QByteArray 使用相同算法如 QString ，但 16 字节对应 16 字符。

QList <T> 也使用算法，但 16 个字节对应 16 个/sizeof(T) 元素。

QHash <Key, T> 是完全不同的情况。 QHash 's internal hash table grows by powers of two, and each time it grows, the items are relocated in a new bucket, computed as qHash ( key ) % QHash::capacity () (the number of buckets). This remark applies to QSet <T> 和 QCache <Key, T> as well.

For most applications, the default growing algorithm provided by Qt does the trick. If you need more control, QList <T>, QHash <Key, T>, QSet <T>, QString ，和 QByteArray provide a trio of functions that allow you to check and specify how much memory to use to store the items:

capacity () 返回分配的内存项数 (对于 QHash and QSet ，哈希表桶数)。
reserve ( size ) 明确预分配内存为 size 项。
squeeze () 释放不要求存储项的任何内存。

若大概知道将在容器中存储多少项，开始可以通过调用 reserve (), and when you are done populating the container, you can call squeeze () to release the extra preallocated memory.

容器类

介绍

容器类