QList Class

成员函数文档

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

如果该列表不是共享的，capacity() 将被保留。使用squeeze() 删除多余的容量。

该函数在 Qt 6.0 中引入。

另请参阅 size()。

在列表开头插入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()。

在容器末尾添加一个新元素。新元素是使用args 作为参数就地构建的。

返回新元素的引用。

示例

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

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

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

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

另请参见 emplace 。

在列表中i 的索引位置插入value 。如果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()。

这是一个重载函数。

在迭代器before 指向的项目前插入value 。返回指向插入项的迭代器。

用value 替换索引位置i 上的项目。

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

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

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

它返回列表理论上可容纳元素的最大数量。实际上，受系统可用内存量的限制，这个数字可能会小得多。

此函数在 Qt 6.8 中引入。

返回一个列表，其中包含此列表中的所有项目，然后是other 列表中的所有项目。

另请参阅 operator+=()。

[constexpr noexcept] QList::QList()

构造一个空列表。

另请参阅 resize().

[explicit] QList::QList(qsizetype size)

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

元素用默认构造值初始化。

另请参见 resize()。

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

用args 给定的 std::initializer_list 构造一个 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 的 list。每个元素的初始化值为value 。

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

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

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

QList 将尝试不初始化元素。

具体来说

• 如果T 的构造函数接受Qt::Uninitialized ，则将使用该构造函数初始化元素；
• 否则，将默认构造每个元素。对于微不足道的可构造类型（如int,float 等），这等同于不初始化它们。

此函数在 Qt 6.8 中引入。

另请参阅 resizeForOverwrite().

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

构造other 的副本。

由于 QList 是隐式共享的，因此该操作耗时不变。这使得从函数返回 QList 的速度非常快。如果共享实例被修改，它将被复制（写时复制），这需要线性时间。

另请参见 operator=()。

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

Move-构建一个 QList 实例，使其指向other 所指向的同一对象。

[default] 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 必须是列表中有效的索引位置（即 0 <= < () ）。i 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

返回指向列表中第一个项目的 ConstSTL 样式迭代器。

另请参阅 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

返回指向列表中第一个项目的 ConstSTL 样式迭代器。

另请参阅 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()。

[noexcept] qsizetype QList::count() const

这是一个重载函数。

与size() 相同。

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

返回一个 ConstSTL 样式的反向迭代器，按相反顺序指向列表中的第一个项目。

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

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

返回一个 ConstSTL 样式的反向迭代器，以相反的顺序指向列表中最后一个项目之后。

另请参阅 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

这是一个重载函数。

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 作为参数就地创建的。

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

[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()。

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

在迭代器before 指向的项目前插入count 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]

[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

从索引位置from 开始向后搜索，返回值value 在列表中最后出现的索引位置。如果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() 。

[noexcept] qsizetype QList::length() const

与size() 和count() 相同。

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

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

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

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

void QList::push_back(QList<T>::rvalue_ref 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 返回 true 的所有元素。如果有，则返回已移除元素的数目。

此函数在 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

这是一个重载函数。

void QList::reserve(qsizetype size)

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

如果事先知道列表有多大，就应该调用此函数，以防止重新分配和内存碎片。如果经常调整列表大小，还可能获得更好的性能。

如果对所需空间有疑问，通常最好使用一个上限作为size ，或者对最有可能的大小做一个较高的估计，如果严格的上限会比它大得多的话。如果size 是一个低估值，那么一旦超过预留大小，列表就会根据需要增长，这可能会导致比最佳高估值更大的分配，并会减慢触发操作的速度。

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

[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()。

[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==()。

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<() 的实现。

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

Move-assignsother 到此QList 实例。

[default] 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

这是一个重载函数。

与 at(i) 相同。