QList Class

成员函数文档

[constexpr noexcept default] QList::QList()

构建一个空列表。

另请参阅 ` resize()`。

[explicit] QList::QList(qsizetype size)

构建一个初始大小为size 个元素的列表。

这些元素将初始化为默认构造的值。

另请参阅 resize()。

QList::QList(std::initializer_list<T> args)

根据args 中给定的std::initializer_list构建一个列表。

template <typename InputIterator, QList<T>::if_input_iterator<InputIterator> = true> QList::QList(InputIterator first, InputIterator last)

构建一个包含迭代器范围 [first,last) 内内容的列表。

InputIterator 的值类型必须可转换为T 。

约束

仅当InputIterator 满足LegacyInputIterator 的要求时，才参与重载解析。

QList::QList(qsizetype size, QList<T>::parameter_type value)

构建一个初始大小为size 个元素的列表。每个元素的初始值均为value 。

另请参阅 resize() 和fill()。

[since 6.8] QList::QList(qsizetype size, Qt::Initialization)

构建一个初始大小为size 个元素的列表。

QList 将尝试不初始化这些元素。

具体来说：

• 如果T 具有一个接受Qt::Uninitialized 作为参数的构造函数，则将使用该构造函数来初始化元素；
• 否则，每个元素将通过默认构造函数进行初始化。对于可简单构造的类型（如int 、float 等），这相当于不初始化它们。

该函数于 Qt 6.8 中引入。

另请参见 resizeForOverwrite()。

[implicit] QList::QList(const QList<T> &other)

创建other 的副本。

此操作耗时为常数时间，因为 QList 是隐式共享的。这使得从函数中返回 QList 非常快速。如果共享的实例被修改，则会进行复制（写时复制），这需要线性时间。

另请参阅 operator=()。

[implicit] QList::QList(QList<T> &&other)

通过“move”操作构造一个 QList 实例，使其指向与other 所指向的同一对象。

[implicit] QList::~QList()

销毁该列表。

void QList::append(QList<T>::parameter_type value)

将value 插入列表末尾。

示例：

QList<QString> list;
list.append("one");
list.append("two");
QString three = "three";
list.append(three);
// list: ["one", "two", "three"]
// three: "three"

这相当于调用 resize(size() + 1)，并将value 赋值给列表中的新末尾元素。

此操作相对较快，因为QList 通常会预留比实际所需更多的内存，因此可以在无需每次重新分配整个列表的情况下扩展。

另请参阅 operator<<()、prepend() 和insert()。

[since 6.0] void QList::append(QList<T> &&value)

将value 列表中的项目移动到该列表的末尾。

该函数在 Qt 6.0 中引入。

另请参阅 operator<<() 和operator+=()。

void QList::append(QList<T>::rvalue_ref value)

示例：

QList<QString> list;
list.append("one");
list.append("two");
QString three = "three";
list.append(std::move(three));
// list: ["one", "two", "three"]
// three: ""

void QList::append(const QList<T> &value)

将value 列表中的项目追加到此列表中。

另请参阅 operator<<() 和operator+=()。

[since 6.6] QList<T> &QList::assign(std::initializer_list<T> l)

将此列表的内容替换为l 中元素的副本。

该列表的大小将等于l 中的元素个数。

只有当l 中的元素数量超过该列表的容量，或者该列表为共享列表时，此函数才会分配内存。

该函数于 Qt 6.6 中引入。

[since 6.6] template <typename InputIterator, QList<T>::if_input_iterator<InputIterator> = true> QList<T> &QList::assign(InputIterator first, InputIterator last)

将此列表的内容替换为迭代器范围 [first,last) 中元素的副本。

该列表的大小将等于范围 [first,last) 中的元素个数。

只有当范围中的元素数量超过该列表的容量，或者该列表是共享的时，此函数才会分配内存。

约束

只有当InputIterator 满足LegacyInputIterator 的要求时，才参与重载解析。

该函数在 Qt 6.6 中引入。

[since 6.6] QList<T> &QList::assign(qsizetype n, QList<T>::parameter_type t)

将此列表的内容替换为n 个t 的副本。

该列表的大小将等于n 。

只有当n 超过列表的容量，或者该列表是共享的，此函数才会分配内存。

该函数自 Qt 6.6 起引入。

[noexcept] QList<T>::const_reference QList::at(qsizetype i) const

返回列表中索引位置为i 的项目。

i i 必须是列表中的有效索引位置（即 0 <= < ())。size

另请参阅 value() 和operator[]()。

QList<T>::reference QList::back()

提供此函数是为了兼容 STL。它等同于 `last()`。

[noexcept] QList<T>::const_reference QList::back() const

QList<T>::iterator QList::begin()

返回一个指向列表中第一个元素的STL 风格迭代器。

另请参阅 constBegin() 和end()。

[noexcept] QList<T>::const_iterator QList::begin() const

qsizetype QList::capacity() const

返回列表在不强制重新分配内存的情况下所能存储的最大项目数。

此函数的唯一目的是提供一种精细调整QList 内存使用情况的手段。通常情况下，您几乎不需要调用此函数。若要了解列表中包含多少个项目，请调用size()。

另请参阅 reserve() 和squeeze()。

[noexcept] QList<T>::const_iterator QList::cbegin() const

返回一个指向列表中第一个元素的常量STL 风格迭代器。

另请参阅 begin() 和cend()。

[noexcept] QList<T>::const_iterator QList::cend() const

返回一个指向列表中最后一个元素之后位置的常量STL 风格迭代器。

另请参阅 cbegin() 和end()。

void QList::clear()

从列表中移除所有元素。

如果该列表未共享，则会保留capacity()。请使用squeeze()来释放多余的容量。

另请参阅 resize() 和squeeze()。

[noexcept] QList<T>::const_iterator QList::constBegin() const

返回一个指向列表中第一个元素的常量STL 风格迭代器。

另请参阅 begin() 和constEnd()。

[noexcept] QList<T>::const_pointer QList::constData() const

返回一个指向列表中存储数据的常量指针。该指针可用于访问列表中的项目。

该函数主要用于将列表传递给接受普通 C++ 数组的函数。

另请参阅 data() 和operator[]()。

[noexcept] QList<T>::const_iterator QList::constEnd() const

返回一个指向列表中最后一个元素之后位置的常量STL 风格迭代器。

另请参阅 constBegin() 和end()。

[noexcept] const T &QList::constFirst() const

返回列表中第一个元素的常量引用。该函数假设列表不为空。

另请参阅 constLast()、isEmpty() 和first()。

[noexcept] const T &QList::constLast() const

返回列表中最后一个元素的常量引用。该函数假设列表不为空。

另请参阅 constFirst()、isEmpty()、以及last()。

[noexcept] template <typename AT> bool QList::contains(const AT &value) const

如果列表中包含value ，则返回true ；否则返回false 。

此函数要求值类型实现了operator==() 接口。

另请参阅 indexOf() 和count()。

[noexcept] template <typename AT = T> qsizetype QList::count(const AT &value) const

返回列表中value 的出现次数。

此函数要求该值类型实现了 `operator==()` 接口。

另请参阅 contains() 和indexOf()。

[constexpr noexcept] qsizetype QList::count() const

与size()相同。

[noexcept] QList<T>::const_reverse_iterator QList::crbegin() const

返回一个指向列表中第一个元素的常量STL 风格反向迭代器，顺序为反向。

另请参阅 begin()、rbegin() 和rend()。

[noexcept] QList<T>::const_reverse_iterator QList::crend() const

返回一个常量STL 风格的反向迭代器，该迭代器指向列表中最后一个元素之后的下一位置，且按反向顺序排列。

另请参阅 end()、rend() 和rbegin()。

QList<T>::pointer QList::data()

返回指向列表中存储的数据的指针。该指针可用于访问和修改列表中的项目。

示例：

QList<int> list(10);
int *data = list.data();
for (qsizetype i = 0; i < 10; ++i)
    data[i] = 2 * i;

该函数主要用于将列表传递给接受普通 C++ 数组的函数。

另请参阅 constData() 和operator[]()。

[noexcept] QList<T>::const_pointer QList::data() const

void QList::detach()

确保该QList 的数据不再与其他实例共享。

template <typename... Args> QList<T>::iterator QList::emplace(qsizetype i, Args &&... args)

通过在位置i 处插入一个新元素来扩展容器。该新元素使用args 作为构造参数，在原地进行构造。

返回指向新元素的迭代器。

示例：

QList<QString> list{"a", "ccc"};
list.emplace(1, 2, 'b');
// list: ["a", "bb", "ccc"]

另请参阅 emplaceBack 。

template <typename... Args> QList<T>::iterator QList::emplace(QList<T>::const_iterator before, Args &&... args)

在迭代器before 所指向的项之前创建一个新元素。该新元素采用就地构建方式，并以args 作为其构造的参数。

返回指向该新元素的迭代器。

在容器的末尾添加一个新元素。该新元素使用args 作为构造参数，在原地进行构造。

返回新元素的引用。

示例：

QList<QString>list{"one", "two"};
list.emplaceBack(3, 'a');
qDebug() << list;
// 列表：["one", "two", "aaa"]

也可以通过返回的引用来访问新创建的对象：

QList<QString> list;
auto &ref = list.emplaceBack();
ref = "one";
// list: ["one"]

这与 list.emplace(list.size(),args) 的效果相同。

另请参阅 emplace 。

[noexcept] bool QList::empty() const

提供此函数是为了兼容 STL。它等同于 `isEmpty()`，如果列表为空，则返回 `true `；否则返回 `false`。

QList<T>::iterator QList::end()

返回一个STL 风格的迭代器，该迭代器指向列表中最后一个元素的下一位置。

另请参阅 ` begin()` 和 `constEnd()`。

[noexcept] QList<T>::const_iterator QList::end() const

bool QList::endsWith(QList<T>::parameter_type value) const

如果该列表不为空且其最后一个元素等于value ，则返回true ；否则返回false 。

另请参阅 isEmpty() 和last()。

QList<T>::iterator QList::erase(QList<T>::const_iterator pos)

从列表中移除由迭代器pos 所指向的元素，并返回指向列表中下一个元素的迭代器（该迭代器可能是end()）。

删除元素不会减少列表的容量，也不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请调用squeeze()。

另请参阅 insert() 和remove()。

QList<T>::iterator QList::erase(QList<T>::const_iterator begin, QList<T>::const_iterator end)

从begin 中移除所有元素，直至（但不包括）end 。返回一个迭代器，该迭代器指向调用前end 所引用的同一项。

删除元素不会改变列表的容量，也不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请调用squeeze()。

QList<T> &QList::fill(QList<T>::parameter_type value, qsizetype size = -1)

将value 赋值给列表中的所有项目。如果size 不等于-1（默认值），则会预先将列表调整为size 的大小。

示例：

QList<QString> list(3);
list.fill("Yes");
// list: ["Yes", "Yes", "Yes"]

list.fill("oh", 5);
// list: ["oh", "oh", "oh", "oh", "oh"]

另请参阅 resize()。

T &QList::first()

返回列表中第一个元素的引用。该函数假设列表不为空。

另请参阅 last()、isEmpty() 和constFirst()。

[since 6.0] QList<T> QList::first(qsizetype n) const

返回一个子列表，其中包含该列表的前n 个元素。

该函数在 Qt 6.0 中引入。

另请参阅 last() 和sliced()。

[noexcept] const T &QList::first() const

QList<T>::reference QList::front()

提供此函数是为了兼容 STL。它等同于 `first()`。

[noexcept] QList<T>::const_reference QList::front() const

[noexcept] template <typename AT> qsizetype QList::indexOf(const AT &value, qsizetype from = 0) const

返回列表中value 首次出现的位置索引，从索引位置from 开始向前搜索。若未找到匹配项，则返回-1。

示例：

QList<QString> list{"A", "B", "C", "B", "A"};
list.indexOf("B");            // returns 1
list.indexOf("B", 1);         // returns 1
list.indexOf("B", 2);         // returns 3
list.indexOf("X");            // returns -1

此函数要求该值类型实现了 `operator==()` 方法。

另请参阅 lastIndexOf() 和contains()。

将value 插入到列表的索引位置i 处。如果i 为0，则将该值插入到列表开头；如果i 为size()，则将该值插入到列表末尾。

示例：

QList<QString> list = {"alpha", "beta", "delta"};
list.insert(2, "gamma");
// list: ["alpha", "beta", "gamma", "delta"]

对于大型列表，此操作可能较慢（线性时间），因为它需要将索引为i 及以上的所有项在内存中向后移动一个位置。如果您需要一个提供快速insert() 函数的容器类，请改用 std::list。

另请参阅 append()、prepend() 和remove()。

QList<T>::iterator QList::insert(QList<T>::const_iterator before, qsizetype count, QList<T>::parameter_type value)

在迭代器before 所指向的项目前面插入count 个value 的副本。返回一个指向已插入项目中第一个项目的迭代器。

在迭代器before 所指向的项之前插入value 。返回一个指向已插入项的迭代器。

QList<T>::iterator QList::insert(qsizetype i, qsizetype count, QList<T>::parameter_type value)

在列表的索引位置i 处插入count 个value 的副本。

示例：

QList<double> list = {2.718, 1.442, 0.4342};
list.insert(1, 3, 9.9);
// list: [2.718, 9.9, 9.9, 9.9, 1.442, 0.4342]

[constexpr noexcept] bool QList::isEmpty() const

如果列表的大小为 0，则返回true ；否则返回false 。

另请参阅 size() 和resize()。

T &QList::last()

返回列表中最后一个元素的引用。该函数假设列表不为空。

另请参阅 first()、isEmpty()，以及constLast()。

[since 6.0] QList<T> QList::last(qsizetype n) const

返回一个子列表，其中包含该列表中最后n 个元素。

该函数在 Qt 6.0 中引入。

另请参阅 first() 和sliced()。

[noexcept] const T &QList::last() const

[noexcept] template <typename AT> qsizetype QList::lastIndexOf(const AT &value, qsizetype from = -1) const

返回列表中值value 最后一次出现的索引位置，从索引位置from 开始向后搜索。如果from 为-1（默认值），则从最后一个元素开始搜索。如果没有匹配的元素，则返回-1。

示例：

QList<QString> list = {"A", "B", "C", "B", "A"};
list.lastIndexOf("B");        // returns 3
list.lastIndexOf("B", 3);     // returns 3
list.lastIndexOf("B", 2);     // returns 1
list.lastIndexOf("X");        // returns -1

此函数要求该值类型实现了operator==() 接口。

另请参阅 indexOf()。

[constexpr noexcept] qsizetype QList::length() const

与size() 和count() 相同。

另请参阅 size() 和count()。

它返回列表理论上能容纳的元素最大数量。实际上，该数值可能会小得多，具体取决于系统可用的内存大小。

这些函数在 Qt 6.8 中首次引入。

QList<T> QList::mid(qsizetype pos, qsizetype length = -1) const

返回一个子列表，其中包含该列表中从位置pos 开始的元素。如果length 为-1（默认值），则包含pos 之后的所有元素；否则，包含length 个元素（如果元素数量少于length 个，则包含所有剩余元素）。

void QList::move(qsizetype from, qsizetype to)

将索引位置为from 的项目移动到索引位置to 。

from 且to 必须在数组边界范围内。

例如，要将第一个元素移动到列表末尾：

QList<int>list={1, 2, 3};
list.move(0,list.size()- 1);
qDebug() << list; // Prints "QList(2, 3, 1)"

[noexcept] void QList::pop_back()

提供此函数是为了与STL兼容。它等同于removeLast()。

[noexcept] void QList::pop_front()

提供此函数是为了兼容 STL。它等同于 `removeFirst()`。

将value 插入列表开头。

示例：

QList<QString> list;
list.prepend("one");
list.prepend("two");
list.prepend("three");
// list: ["three", "two", "one"]

这与 list.insert(0,value) 的效果相同。

通常，此操作速度相对较快（摊还时间复杂度为常数）。QList 能够在列表数据开头分配额外内存，并朝该方向扩展，而无需在每次操作时重新分配内存或移动数据。但是，如果您需要一个能保证前缀插入时间复杂度为常数的容器类，请改用 std::list；否则，建议优先使用QList 。

另请参阅 append() 和insert()。

void QList::push_back(QList<T>::parameter_type value)

提供此函数是为了与 STL 兼容。它等同于 append(value)。

void QList::push_back(QList<T>::rvalue_ref value)

提供此函数是为了兼容 STL。它等同于 prepend(value)。

QList<T>::reverse_iterator QList::rbegin()

返回一个STL 风格的反向迭代器，该迭代器指向列表中第一个元素，且顺序为反向。

另请参阅 begin()、crbegin() 和rend()。

[noexcept] QList<T>::const_reverse_iterator QList::rbegin() const

void QList::remove(qsizetype i, qsizetype n = 1)

从列表中移除索引位置为i 开始的n 个元素。

移除元素时将保留列表的容量，不会减少已分配的内存。若要释放多余的容量并尽可能释放内存，请调用squeeze()。

另请参阅 insert()、replace() 和fill()。

template <typename AT = T> qsizetype QList::removeAll(const AT &t)

从列表中移除所有与t 相等的元素。若移除了元素，则返回移除的元素个数。

移除元素不会减少列表的容量，也不会减少已分配的内存。若要释放多余的容量并尽可能多地释放内存，请调用squeeze()。

另请参阅 removeOne()。

void QList::removeAt(qsizetype i)

移除索引位置为i 的元素。等同于

remove(i);

删除元素不会减少列表的容量，也不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请调用squeeze()。

另请参阅 remove()。

[noexcept] void QList::removeFirst()

移除列表中的第一个元素。调用此函数等同于调用 remove(0)。列表不能为空。如果列表可以为空，请在调用此函数之前先调用isEmpty()。

删除元素不会减少列表的容量，也不会减少已分配的内存量。若要释放多余的容量并尽可能释放更多内存，请调用squeeze()。

另请参阅 remove()、takeFirst() 和isEmpty()。

[since 6.1] template <typename Predicate> qsizetype QList::removeIf(Predicate pred)

从列表中移除所有满足谓词 `pred ` 为真条件的元素。如果移除了元素，则返回移除的元素个数。

该函数在 Qt 6.1 中引入。

另请参阅 removeAll()。

[noexcept] void QList::removeLast()

移除列表中的最后一个元素。调用此函数等同于调用 remove(size() - 1)。列表不能为空。如果列表可以为空，请在调用此函数之前先调用isEmpty()。

删除元素不会减少列表的容量，也不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请调用squeeze()。

另请参阅 remove()、takeLast()、removeFirst() 和isEmpty()。

template <typename AT = T> bool QList::removeOne(const AT &t)

从列表中移除第一个与t 相等的元素。返回是否确实移除了该元素。

移除元素不会减少列表的容量，也不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请调用squeeze()。

另请参阅 removeAll()。

QList<T>::reverse_iterator QList::rend()

返回一个STL 风格的反向迭代器，该迭代器指向列表中最后一个元素之后的下一个位置，且顺序为反向。

另请参阅 end()、crend() 和rbegin()。

[noexcept] QList<T>::const_reverse_iterator QList::rend() const

将索引位置为i 的项替换为value 。

i i 必须是列表中的有效索引位置（即 0 <= < ())。size

另请参阅 operator[]() 和remove()。

void QList::reserve(qsizetype size)

尝试为至少size 个元素分配内存。

如果您事先知道列表的大小，应调用此函数以避免内存重新分配和内存碎片化。如果您经常调整列表的大小，性能通常也会得到提升。

如果对所需空间大小不确定，通常最好将上界设为size ，或者如果严格的上界远大于此值，则采用对最可能大小的较高估计值。 如果size 被低估，一旦预留大小被超过，列表将按需扩展，这可能会导致比你最佳高估值更大的内存分配，并会减慢触发该操作的操作速度。

另请参阅 squeeze()、capacity() 和resize()。

将列表的大小设置为size 。如果size 大于当前大小，则将元素追加到列表末尾；新元素将使用默认构造值或c 进行初始化。如果size 小于当前大小，则从列表末尾移除元素。

如果该列表不是共享的，则会保留capacity()。请使用squeeze()来释放多余的容量。

这些函数是在 Qt 6.0 中引入的。

另请参阅 size()。

[since 6.8] void QList::resizeForOverwrite(qsizetype size)

将列表的大小设置为size 。如果size 小于当前大小，则从列表末尾移除元素；如果size 大于当前大小，则在列表末尾添加元素；QList 将尝试不初始化这些新元素。

具体而言：

• 如果T 具有一个接受Qt::Uninitialized 的构造函数，则将使用该构造函数来初始化这些元素；
• 否则，每个元素将进行默认构造。对于可简单构造的类型（如int 、float 等），这相当于不初始化它们。

该函数于 Qt 6.8 中引入。

void QList::shrink_to_fit()

提供此函数是为了兼容 STL。它等同于 `squeeze()`。

[constexpr noexcept] qsizetype QList::size() const

返回列表中的项目数量。

另请参阅 isEmpty() 和resize()。

[since 6.0] QList<T> QList::sliced(qsizetype pos, qsizetype n) const

返回一个子列表，其中包含该列表中从位置pos 开始的n 个元素。

该函数在 Qt 6.0 中引入。

另请参阅 first() 和last()。

[since 6.0] QList<T> QList::sliced(qsizetype pos) const

返回一个子列表，其中包含该列表从位置pos 开始直至末尾的所有元素。

该函数于 Qt 6.0 中引入。

另请参阅 first() 和last()。

void QList::squeeze()

释放存储这些项目所不需要的内存。

此函数的唯一目的是提供一种方法来微调QList 的内存使用情况。通常情况下，您几乎无需调用此函数。

另请参阅 reserve() 和capacity()。

bool QList::startsWith(QList<T>::parameter_type value) const

如果该列表不为空且其第一个元素等于value ，则返回true ；否则返回false 。

另请参阅 isEmpty() 和first()。

[noexcept] void QList::swap(QList<T> &other)

将此列表与other 互换。此操作速度极快，且绝不会失败。

void QList::swapItemsAt(qsizetype i, qsizetype j)

将索引位置为i 的项与索引位置为j 的项互换。该函数假设i 和j 均不小于0且小于size()。为避免出错，请验证i 和j 均不小于0且小于size()。

T QList::takeAt(qsizetype i)

移除索引位置为i 的元素并返回该元素。

等同于

T t = at(i);
remove(i);
return t;

另请参阅 takeFirst() 和takeLast()。

QList<T>::value_type QList::takeFirst()

移除列表中的第一个元素并返回该元素。此函数假设列表不为空。为避免出错，请在调用此函数之前先调用isEmpty()。

另请参阅 takeLast() 和removeFirst()。

QList<T>::value_type QList::takeLast()

移除列表中的最后一个元素并返回该元素。该函数假设列表不为空。为避免出错，请在调用此函数之前先调用isEmpty()。

如果您不使用返回值，removeLast() 的效率更高。

另请参阅 takeFirst() 和removeLast()。

T QList::value(qsizetype i) const

返回列表中索引位置为i 的值。

如果索引i 超出范围，该函数将返回一个默认构造的值。如果您确定i 在范围内，可以使用at() 代替，其执行速度会稍快一些。

另请参阅 at() 和operator[]()。

T QList::value(qsizetype i, QList<T>::parameter_type defaultValue) const

如果索引i 超出范围，该函数将返回defaultValue 。

bool QList::operator!=(const QList<T> &other) const

如果 `other ` 与该列表不相同，则返回 `true `；否则返回 `false`。

如果两个列表包含相同的值且顺序相同，则认为它们相等。

此函数要求该值类型实现了operator==() 接口。

另请参阅 operator==()。

返回一个列表，其中包含该列表中的所有项目，以及紧随其后的other 列表中的所有项目。

另请参阅 operator+=()。

QList<T> &QList::operator+=(const QList<T> &other)

将other 列表中的项目追加到该列表中，并返回该列表的引用。

另请参阅 operator+() 和append()。

[since 6.0] QList<T> &QList::operator+=(QList<T> &&other)

该函数在 Qt 6.0 中引入。

另请参阅 operator+() 和append()。

QList<T> &QList::operator+=(QList<T>::parameter_type value)

将value 追加到列表中。

另请参阅 append() 和operator<<()。

QList<T> &QList::operator+=(QList<T>::rvalue_ref value)

另请参阅 append() 和operator<<()。

bool QList::operator<(const QList<T> &other) const

如果该列表在词法上小于 other，则返回true ；否则返回false 。

该函数要求值类型实现了operator<() 接口。

QList<T> &QList::operator<<(QList<T>::parameter_type value)

将value 追加到列表中，并返回该列表的引用。

另请参阅 append() 和operator+=()。

QList<T> &QList::operator<<(const QList<T> &other)

将other 追加到列表中，并返回该列表的引用。

[since 6.0] QList<T> &QList::operator<<(QList<T> &&other)

该函数在 Qt 6.0 中引入。

QList<T> &QList::operator<<(QList<T>::rvalue_ref value)

另请参阅 append() 和operator+=()。

bool QList::operator<=(const QList<T> &other) const

如果该列表在词法上小于或等于 other ，则返回true ；否则返回false 。

该函数要求值类型实现了operator<() 函数。

[implicit] QList<T> &QList::operator=(QList<T> &&other)

将other 通过Move操作赋值给此QList 实例。

[implicit] QList<T> &QList::operator=(const QList<T> &other)

将other 赋值给此列表，并返回对此列表的引用。

QList<T> &QList::operator=(std::initializer_list<T> args)

将args 中的值集合赋给此QList 实例。

bool QList::operator==(const QList<T> &other) const

如果 `other ` 与该列表相等，则返回 `true `；否则返回 `false`。

如果两个列表包含相同的值且顺序相同，则认为它们相等。

此函数要求该值类型实现了operator==() 方法。

另请参阅 operator!=()。

bool QList::operator>(const QList<T> &other) const

如果该列表在词法意义上大于 ` other`，则返回 `true `；否则返回 `false`。

该函数要求值类型实现了operator<() 。

bool QList::operator>=(const QList<T> &other) const

如果该列表在词法上大于或等于 other ，则返回true ；否则返回false 。

该函数要求值类型实现了operator<() 。

QList<T>::reference QList::operator[](qsizetype i)

返回索引位置为i 的项目，作为可修改的引用。

i 该索引位置必须是列表中的有效索引位置（即，0 <=i <size())。

请注意，使用非 const 运算符可能会导致QList 执行深度复制。

另请参阅 at() 和value()。

[noexcept] QList<T>::const_reference QList::operator[](qsizetype i) const

与 (i) 相同。