QT QList＜T＞介绍与应用、详解、使用说明、官方手册翻译

link之家
链接快照平台
输入网页链接，自动生成快照
标签化管理网页链接
1. 简介

QList<T>是目前最常用的容器类。它存储了给定类型的值的一个列表，而这些值可以通过索引访问。在内部，QList使用数组来实现，一确保进行快速的基于索引的访问。可以使用QList::append()和QList::prepend()在列表的两端添加项目，也可以使用QList::insert()在列表的中间插入项目。常用的QStringList继承自QList<QString>。
2. 使用示例

#include <QCoreApplication>
#include <QList>
#include <QDebug>
int main(int argc, char *argv[])
    QCoreApplication a(argc, argv);
	// 定义QList变量
    QList<QString> list;
	// 插入项目
    list << "aa" << "bb" << "cc"; 
    // 查询和重新定义元素
    if(list[1] == "bb")
    	list[1] = "ab";
	// 替换第3个元素
    list.replace(2, "bc");        // 将“cc”换为“bc”
	// 打印元素
	qDebug() << "the list is: ";
    for(int i=0; i<list.size(); ++i){
        qDebug() << list.at(i);   // 现在列表为aa ab bc
	// 在列表尾部添加元素
    list.append("dd");
    // 在列表头部添加元素
    list.prepend("mm");   
    // 从列表中删除第3个项目，并获取它        
    QString str = list.takeAt(2); 
	// 打印刚才删除的元素
    qDebug() << "at(2) item is: " << str;
    // 打印列表
    qDebug() << "the list is: ";
    for(int i=0; i<list.size(); ++i)
        qDebug() << list.at(i);   // 现在列表为mm aa bc dd
	// 在位置2插入项目
    list.insert(2, "mm");
    // 交换项目1和项目3
    list.swap(1,3);
    // 打印列表
    qDebug() << "the list is: ";
    for(int i=0; i<list.size(); ++i)
        qDebug() << list.at(i);   // 现在列表为mm bc mm aa dd
	// 列表中是否包含“mm”
    qDebug() << "contains 'mm' ?" << list.contains("mm"); 
    // 包含“mm”的个数
    qDebug() << "the 'mm' count: " << list.count("mm"); 
    // 第一个“mm”的位置，默认从位置0开始往前查找，返回第一个匹配的项目的位置
    qDebug() << "the first 'mm' index: " << list.indexOf("mm");
    // 第二个“mm”的位置，我们指定从位置1开始往前查找
    qDebug() << "the second 'mm' index: " << list.indexOf("mm", 2);
    return a.exec();
执行结果：
 
 程序说明： 
    QList<QString> list;
    list << "aa" << "bb" << "cc"; // 插入项目
	list[0] = "aa";
	list.replace(2, "bc");
	int length = list.size();
获取元素值 
	list.at(i)
在列表尾部添加 
	list.append("dd");
在列表头部添加 
	list.prepend("mm"); 
删除元素并获取 
	QString str = list.takeAt(2);
在指定位置插入 
	list.insert(2, "mm");
	list.swap(1,3); 
列表是否包含某值 
	list.contains("mm"); 
列表包含某值个数 
	list.count("mm"); 
元素位置，从0开始查找 
	list.indexOf("mm");
元素位置，从指定位置查找 
	list.indexOf("mm", 2);
3. 官方手册
 
https://doc.qt.io/qt-5/qlist.html 
4. Member Function Documentation
 
QList::QList(InputIterator first, InputIterator last)
构造一个包含迭代器范围[first, last]中的内容的QList。
 InputIterator的值类型必须转换为T。
 这个函数是在Qt 5.14中引入的。 
QList::QList(std::initializer_list<T> args)
从args指定的std::initializer_list构造一个列表。
 这个构造函数只有在编译器支持c++ 11初始化器列表时才启用。
 这个函数是在Qt 4.8中引入的。 
QList::




    
QList(QList<T> &&other)
Move构造一个QList实例，使其指向其他对象指向的同一对象。
 此功能在Qt 5.2中引入。 
QList::QList(const QList<T> &other)
构造其他的副本。
 由于QList是隐式共享的，因此此操作花费的时间是恒定的。 这使得从函数快速返回QList成为可能。 如果共享实例被修改，它将被复制（写时复制），这需要花费线性时间。
 另请参阅operator =（）。 
QList :: QList（）
构造一个空列表。 
QList <T>＆QList :: operator =（QList <T> && other）
将其他移动到此QList实例。
 此功能在Qt 5.2中引入。 
QList <T>＆QList :: operator =（const QList <T>＆other）
将其他分配给该列表，并返回对该列表的引用。 
QList::~QList()
销毁该列表。 对列表中的值的引用以及该列表的所有迭代器均无效。 
void QList::append(const T &value)
在列表的末尾插入值。
 示例：
 
 这与list.insert(size(), value)相同.
 如果未共享此列表，则此操作通常非常快（摊销的固定时间），因为QList在其内部缓冲区的两侧预分配了额外的空间，以允许在列表的两端快速增长。 
另参见operator<<(), prepend(), 和 insert(). 
void QList::append(const QList<T> &value)
这是一个重载功能。
 将值列表的项目追加到此列表。
 此功能在Qt 4.5中引入。 
另参见operator<<() 和 operator+=(). 
const T &QList::at(int i) const
返回列表中索引位置i处的项目。 我必须是列表中的有效索引位置（即 0<=i<size()）。
 此功能非常快（恒定时间）。 
另参见value() 和 operator[](). 
T &QList::back()
提供此功能是为了实现STL兼容性。 它等效于last（）。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。 
const T &QList::back() const
这是一个重载功能。 
QList::iterator QList::begin()
返回一个STL样式的迭代器，该迭代器指向列表中的第一项。 
另参见constBegin() 和 end(). 
QList::const_iterator QList::begin() const
这是一个重载功能 
QList::const_iterator QList::cbegin() const
返回指向列表中第一项的const STL样式迭代器。
 此功能在Qt 5.0中引入。 
另参见begin() 和 cend(). 
QList::const_iterator QList::cend() const
返回一个const STL样式的迭代器，该迭代器指向列表中最后一个项目之后的虚拟项目。
 此功能在Qt 5.0中引入。 
另参见cbegin() 和 end(). 
void QList::clear()
从列表中删除所有项目。 
另参见removeAll(). 
QList::const_iterator QList::constBegin() const
返回指向列表中第一项的const STL样式迭代器。 
另参见 begin() 和constEnd(). 
QList::const_iterator QList::constEnd() const
返回一个const STL样式迭代器，该迭代器指向列表中最后一个项之后的假想项。 
另参见constBegin() 和end(). 
const T &QList::constFirst() const
返回对列表中第一项的常量引用。列表不能为空。如果列表可以为空，请在调用此函数之前调用isEmpty（）。
 qt5.6中引入了这个函数。 
另参见constLast(), isEmpty(), 和 first(). 
const T &QList::constLast() const
返回对列表中最后一项的引用。列表不能为空。如果列表可以为空，请在调用此函数之前调用isEmpty（）。
 qt5.6中引入了这个函数。 
另参见constFirst(), isEmpty(), 和last(). 
bool QList::contains(const T &value) const
如果列表包含值的出现，则返回true；否则返回false。
 此函数要求值类型具有运算符==（）的实现。 
另参见indexOf() 和count(). 
int QList::count(const T &value) const
返回值在列表中出现的次数。
 此函数要求值类型具有运算符==（）的实现。 
另参见contains() 和indexOf(). 
int QList::count() const
返回列表中的项数。这实际上与size（）相同。 
QList::const_reverse_iterator QList::crbegin() const
以相反的顺序返回指向列表中第一项的const STL样式反向迭代器。
 qt5.6中引入了这个函数。 
另参见begin(), rbegin(), 和rend(). 
QList::const_reverse_iterator QList::crend() const
以相反的顺序返回一个const STL样式的反向迭代器，该迭代器指向列表中最后一项之后的一个。
 此功能在Qt 5.6中引入。 
另参见end(), rend(), 和 rbegin(). 
bool QList::empty() const
提供此功能是为了实现STL兼容性。 它等效于isEmpty（），如果列表为空，则返回true。 
QList::iterator QList::end()
返回一个STL样式的迭代器，该迭代器指向列表中最后一个项目之后的虚拟项目。 
另请参见begin（）和constEnd（）。 
QList::const_iterator QList::end() const
这是一个重载函数。 
bool QList::endsWith(const T &value) const
如果此列表不为空并且其最后一项等于value，则返回true；否则，返回true。 否则返回false。
 此功能在Qt 4.5中引入。 
另请参见isEmpty（）和contains（）。 
QList::iterator QList::erase(QList::iterator pos)
从列表中删除与迭代器pos关联的项目，并将迭代器返回到列表中的下一个项目（可能是end（））。 
另请参见insert（）和removeAt（）。 
QList::iterator QList::erase(QList::iterator begin, QList::iterator end)
这是一个重载函数。
 从开始到（但不包括）结束删除所有项目。 将迭代器返回到调用之前结束引用的同一项目。 
T &QList::first()
返回对列表中第一项的引用。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。
 另请参见constFirst（），last（）和isEmpty（）。 
const T &QList::first() const
这是一个重载函数。 
[static] QList<T> QList::fromSet(const QSet<T> &set)
返回带有包含在set中的数据的QList对象。 QList中元素的顺序未定义。 
  QSet<int> set;
  set << 20 << 30 << 40 << ... << 70;
  QList<int> list = QList<int>::fromSet(set);
  std::sort(list.begin(), list.end());
注意：从Qt 5.14开始，范围构造函数可用于Qt的通用容器类，并且应代替此方法使用。
 另请参见fromVector（），toSet（）和QSet :: toList（）。 
[static] QList<T> QList::fromStdList(const std::list<T> &list)
返回一个QList对象，列表中包含数据。 QList中元素的顺序与list中的顺序相同。 
  std::list<double> stdlist;
  list.push_back(1.2);
  list.push_back(0.5);
  list.push_back(3.14);
  QList<double> list = QList<double>::fromStdList(stdlist);
注意：从Qt 5.14开始，范围构造函数可用于Qt的通用容器类，并且应代替此方法使用。 
另请参见toStdList（）和QVector :: fromStdVector（）。 
[static] QList<T> QList::fromVector(const QVector<T>




    
 &vector)
返回带有向量中包含的数据的QList对象。 
  QVector<double> vect;
  vect << 20.0 << 30.0 << 40.0 << 50.0;
  QList<double> list = QVector<T>::fromVector(vect);
  // list: [20.0, 30.0, 40.0, 50.0]
注意：从Qt 5.14开始，范围构造函数可用于Qt的通用容器类，并且应代替此方法使用。 
另请参见fromSet（），toVector（）和QVector :: toList（）。 
T &QList::front()
提供此功能是为了实现STL兼容性。 它等效于first（）。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。 
const T &QList::front() const
这是一个重载函数 
int QList::indexOf(const T &value, int from = ...) const
返回列表中第一个出现的值的索引位置，从索引位置from开始向前搜索。 如果没有匹配项，则返回-1。 
  QList<QString> list;
  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 ==（）的实现。
 请注意，QList使用基于0的索引，就像C ++数组一样。 除上述值外，不支持负索引。 
另请参见lastIndexOf（）和contains（）。 
void QList::insert(int i, const T &value)
在列表中索引位置i处插入值。 如果i <= 0，则该值位于列表的前面。 如果i> = size（），则将值附加到列表中。 
Example: 
  QList<QString> list;
  list << "alpha" << "beta" << "delta";
  list.insert(2, "gamma");
  // list: ["alpha", "beta", "gamma", "delta"]
另参见append(), prepend(), replace(), 和removeAt(). 
QList::iterator QList::insert(QList::iterator before, const T &value)
这是一个重载函数。
 在迭代器之前指向的项目前面插入值。 返回指向插入项的迭代器。 注意，调用后传递给该函数的迭代器将无效。 应该使用返回的迭代器代替。 
bool QList::isEmpty() const
如果列表不包含任何项目，则返回true；否则，返回true。 否则返回false。 
See also size(). 
T &QList::last()
返回对列表中最后一项的引用。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。 
See also constLast(), first(), and isEmpty(). 
const T &QList::last() const
这是一个重载函数。 
int QList::lastIndexOf(const T &value, int from = ...) const
返回列表中最后一次出现的值的索引位置，从索引位置from开始向后搜索。 如果from为-1（默认值），则搜索从最后一项开始。 如果没有匹配项，则返回-1。 
Example: 
  QList<QString> list;
  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 ==（）的实现。
 请注意，QList使用基于0的索引，就像C ++数组一样。 除上述值外，不支持负索引。 
See also indexOf(). 
int QList::length() const
此函数与count（）相同。
 此功能在Qt 4.5中引入。 
See also count(). 
QList<T> QList::mid(int pos, int length = -1) const
void QList::move(int from, int to)
将索引位置的项目从移到索引位置。
 Example:
 
 这与insert（to，takeAt（from））相同。此函数假定from和to都至少为0但小于size（）。 为避免失败，请测试from和to两者均至少为0且小于size（）。 
See also swap(), insert(), and takeAt(). 
void QList::pop_back()
提供此功能是为了实现STL兼容性。 它等效于removeLast（）。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。 
void QList::pop_front()
提供此功能是为了实现STL兼容性。 它等效于removeFirst（）。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。 
void QList::prepend(const T &value)
在列表的开头插入值。
 
 这与list.insert（0，value）相同。
 如果未共享此列表，则此操作通常非常快（摊销的固定时间），因为QList在其内部缓冲区的两侧预分配了额外的空间，以允许在列表的两端快速增长。 
See also append() and insert(). 
void QList::push_back(const T &value)
提供此功能是为了实现STL兼容性。 它等效于append（value）。 
void QList::push_front(const T &value)
提供此功能是为了实现STL兼容性。 它等效于prepend（value）。 
QList::reverse_iterator QList::rbegin()
以相反的顺序返回指向列表中第一项的STL样式反向迭代器。
 此功能在Qt 5.6中引入。 
See also begin(), crbegin(), and rend(). 
QList::const_reverse_iterator QList::rbegin() const
这是一个重载函数。
 此功能在Qt 5.6中引入。 
int QList::removeAll(const T &value)
删除列表中所有出现的value并返回删除的条目数。
 
 此函数要求值类型具有operator ==（）的实现。 
See also removeOne(), removeAt(), takeAt(), and replace(). 
void QList::removeAt(int i)
删除索引位置i处的项目。 我必须是列表中的有效索引位置（即0 <= i <size（））。 
See also takeAt(), removeFirst(), removeLast(), and removeOne(). 
void QList::removeFirst()
删除列表中的第一项。 调用此函数等效于调用removeAt（0）。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。 
See also removeAt() and takeFirst(). 
void QList::removeLast()
删除列表中的最后一项。 调用此函数等效于调用removeAt（size（）-1）。 该列表不能为空。 如果列表可以为空，请在调用此函数之前调用isEmpty（）。 
See also removeAt() and takeLast(). 
bool QList::removeOne(const T &value)
删除列表中第一个出现的值，并在成功时返回true； 否则返回false。
 
 此函数要求值类型具有operator ==（）的实现。
 此功能在Qt 4.4中引入。 
See also removeAll(), removeAt(), takeAt(), and replace(). 
QList::reverse_iterator QList::rend()
以相反的顺序返回一个STL样式的反向迭代器，该迭代器指向列表中最后一项之后的一个。
 此功能在Qt 5.6中引入。 
See also end(), crend(), and rbegin(). 
QList::const_reverse_iterator QList::rend() const
这是一个重载功能。
 此功能在Qt 5.6中引入。 
void QList::replace(int i, const T &value)
用值替换索引位置i处的项目。 我必须是列表中的有效索引位置（即0 <= i <size（））。 
See also operator[]() and removeAt(). 
void QList::reserve(int alloc)
为分配元素保留空间。
 如果alloc小于列表的当前大小，则不会发生任何事情。
 如果您可以预测要添加多少个元素，请使用此功能避免重复分配QList内部数据。 请注意，保留仅适用于内部指针数组。
 此功能在Qt 4.7中引入。 
int QList::size() const
返回列表中的项目数。 
See also isEmpty() and count(). 
bool QList::startsWith(const T &value) const
如果此列表不为空并且其第一项等于value，则返回true；否则，返回true。 否则返回false。
 此功能在Qt 4.5中引入。 
See also isEmpty() and contains(). 
void QList::swap(QList<T> &other)
交换其他与此列表。 此操作非常快，并且永远不会失败。
 此功能在Qt 4.8中引入。 
void QList::swapItemsAt(int i, int j)
将索引位置i处的项目与索引位置j处的项目进行交换。 此函数假定i和j都至少为0但小于size（）。 为避免失败，请测试i和j至少为0并小于size（）。
 
 此功能在Qt 5.13中引入。 
See also move(). 
T QList::takeAt(int i)
删除索引位置i处的项目并返回它。 我必须是列表中的有效索引位置（即0 <= i <size（））。
 如果不使用返回值，则removeAt（）会更有效。 
See also removeAt(), takeFirst(), and takeLast(). 
T QList::takeFirst()
删除列表中的第一项并返回它。 这与takeAt（0）相同。 此函数假定列表不为空。 为避免失败，请在调用此函数之前调用isEmpty（）。
 如果未共享此列表，则此操作将花费固定时间。
 如果不使用返回值，则removeFirst（）会更有效。 
See also takeLast(), takeAt(), and removeFirst(). 
T QList::takeLast()
删除列表中的最后一项并返回。 这与takeAt（size（）-1）相同。 此函数假定列表不为空。 为避免失败，请在调用此函数之前调用isEmpty（）。
 如果未共享此列表，则此操作将花费固定时间。
 如果不使用返回值，则removeLast（）会更有效。 
See also takeFirst(), takeAt(), and removeLast(). 
QSet<T> QList::toSet() const
返回带有此QList中包含的数据的QSet对象。 由于QSet不允许重复，因此生成的QSet可能小于原始列表。
 
 注意：从Qt 5.14开始，范围构造函数可用于Qt的通用容器类，并且应代替此方法使用。 
See also toVector(), fromSet(), and QSet::fromList(). 
std::list<T> QList::toStdList() const
返回带有此QList中包含的数据的std :: list对象。 例：
 
 注意：从Qt 5.14开始，范围构造函数可用于Qt的通用容器类，并且应代替此方法使用。 
See also fromStdList() and QVector::toStdVector(). 
QVector<T> QList::toVector() const
返回带有此QList中包含的数据的QVector对象。
 
 注意：从Qt 5.14开始，范围构造函数可用于Qt的通用容器类，并且应代替此方法使用。 
See also toSet(), fromVector(), and QVector::fromList(). 
T QList::value(int i) const
返回列表中索引位置i处的值。
 如果索引i超出范围，则该函数将返回默认构造的值。 如果确定索引将在范围内，则可以使用at（）来代替，这会稍微快一些。 
See also at() and operator[](). 
T QList::value(int i, const T &defaultValue) const
这是一个过载功能。
 如果索引i超出范围，则该函数返回defaultValue。 
bool QList::operator!=(const QList<T> &other) const
如果other不等于此列表，则返回true；否则，返回false。 否则返回false。
 如果两个列表包含相同顺序的相同值，则认为它们相等。
 此函数要求值类型具有operator ==（）的实现。 
See also operator==(). 
QList<T> QList::operator+(const QList<T> &other) const
返回一个列表，其中包含此列表中的所有项目，然后是另一个列表中的所有项目。 
See also operator+=(). 
QList<T> &QList::operator+=(const QList<T> &other)
将另一个列表的项目追加到此列表，并返回对该列表的引用。 
See also operator+() and append(). 
QList<T> &QList::operator+=(const T &value)
这是一个过载功能。
 将值追加到列表。 
See also append() and operator<<(). 
QList<T> &QList::operator<<(const QList<T> &other)
将另一个列表的项目追加到此列表，并返回对该列表的引用。 
See also operator+=() and append(). 
QList<T> &QList::operator<<(const T &value)
这是一个过载功能。
 将值追加到列表。 
bool QList::operator==(const QList<T> &other) const
如果other等于此列表，则返回true；否则，返回true。 否则返回false。
 如果两个列表包含相同顺序的相同值，则认为它们相等。
 此函数要求值类型具有operator ==（）的实现。 
See also operator!=(). 
T &QList::operator[](int i)
返回索引位置i处的项目作为可修改的参考。 我必须是列表中的有效索引位置（即0 <= i <size（））。
 如果在当前正在共享的列表上调用此函数，它将触发所有元素的副本。 否则，此功能将以恒定时间运行。 如果不想修改列表，则应使用QList :: at（）。 
See also at() and value(). 
const T &QList::operator[](int i) const
这是一个重载功能。
 Same as at(). 此函数以恒定时间运行。
                    文章目录1. 简介2. 使用示例3. 官方手册4. Member Function Documentation1. 简介QList&lt;T&gt;是目前最常用的容器类 。它存储了给定类型的值的一个列表，而这些值可以通过索引访问。在内部，QList使用数组来实现，一确保进行快速的基于索引的访问。可以使用QList::append()和QList::prepend()在列表的两端添加项目，也可以使用QList::insert()在列表的中间插入项目。常用的QStringList继承自QList&lt;QS
QList两种存储方式：
1)元素占用空间<指针占用空间(sizeof(T)<sizeof(void*))，并且元素已经使用Q_DECLARE_TYPEINFO声明为 Q_MOVABLE_TYPE 或 Q_PRIMITIVE_TYPE 时，QList以数组形式存储，QVector、QVarLengthArray一样；
2)元素占用空间>指针占用空间时，QList会将每个元素new到堆上，即 QList<T> 表示为 QList<T*&gt
				一文总结Qt序列式容器类—QList
文章目录一文总结Qt序列式容器类—QList一、QList简介二、QList使用方法三、QList常使用的成员函数（3-1）向QList中插入项（3-2）移除QList中的项（3-3）移动QList中的项（3-4）访问QList中的项（3-5）查找QList中的项四、QList使用注意事项五、结尾
一、QList简介
在Qt中，QList类是一个提供列表的模板类，在开发中，也是一个较为常用的序列式容器类。
	在QList内部，如果sizeof(T) <= siz
				QList使用总结概述一、QList 声明及初始化1. 声明 QList2. 初始化 QList二、QList 基本的 增加、删除、移动、修改1. 增加节点2. 删除节点3. 移动节点4. 修改节点值三、QList 定位节点四、QList 的基本信息五、QList 迭代器功能
QList是Qt的泛型容器类之一。它将项目存储在一个列表中，该列表提供基于索引的快速访问以及基于索引的插入和删除。
QList、QLinkedList 和 QVector 提供了类似的 API 和功能。它们通常是可互换的，但性能
				1、QList介绍
介绍个锤子，有点累，摊牌了，这篇是水的，但是我觉得质量很高，因为我自己写不了这么详细，对，感谢某不知名网站编程指南，我直接白嫖，这篇实在是太多了，说句实话日常使用不久存个指针，然后遍历查找之类的，怎么能写这么多！
在开始讲解 QList 之前，我们先明确一下 Qt 数据容器能存储什么，不能存储什么。
Qt 提供的数据容器都是模板类，构造时要带数据类型，比如下面这句定义整型数列表：
QList<int> integerList;
Qt 数据容器有支持的数据类型，也有不支持的类型
2、QList是Qt的一种泛型容器类。它以链表方式存储一组值，并能对这组数据进行快速索引，还提供了快速插入和删除等操作。
3、QList、QLinkedList和QVector提供的操作极其相似： 
    * 对大多数操作来说，我们用QList就可以了。其API是基于索引（index）的，因此用起来比QLinkedList更方便（QLinkedList...
				实例CH201,通过控制台程序实现QList只读遍历方法。
(a) 头文件<QDebug>中已经包含了QList的头文件。
(b)Qt的一些类，如QString、QList等，不需要QCoreApplication的支持也能够工作，但是，在使用Qt编写应用程序时，如果是控制台应用程序，则建议初始化一个QCoreApplication对象，Qt 5.8创建控制台项目时生成的main.cpp源文件中默认就创建了一个QcoreApplication对象；如果是GUI图形用户界面程序，则会初始化一个QApplication对象。
(c) QListIterator<int> i(list)：以该list为参数初始化一个QListIterator对象i。此时，迭代点处在第一个列表项“1”的前面（注意，并不是指向该列表项）。
(d) for(;i.hasNext();)：调用QListIterator<T>::hasNext()函数检查当前迭代点之后是否有列表项。
				QList<QList>是一个非常有用的数据类型，特别是在处理二维数据时。它允许您在一个QList中存储多个QList，每个QList都可以包含不同数量和类型的元素。以下是一些使用QList<QList>的常见示例：
1. 创建一个3x3的矩阵，并将其所有元素初始化为0：
QList<QList<int>> matrix;
matrix.resize(3);
for (int i = 0; i < 3; i++) {
    matrix[i].resize(3);
    for (int j = 0; j < 3; j++) {
        matrix[i][j] = 0;
2. 将多个QList合并成一个QList：
QList<int> list1 = {1, 2, 3};
QList<int> list2 = {4, 5, 6};
QList<int> list3 = {7, 8, 9};
QList<QList<int>> matrix;
matrix << list1 << list2 << list3;
3. 计算一个3x3矩阵的行总和和列总和：
QList<QList<int>> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
QList<int> rowSum(3, 0);
QList<int> colSum(3, 0);
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        rowSum[i] += matrix[i][j];
        colSum[j] += matrix[i][j];
总之，QList<QList>可以用于存储和处理二维数据，它提供了一种方便的方法来组织和操作多个QList。