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

最新推荐文章于 2024-05-03 22:07:47 发布

ken2232

最新推荐文章于 2024-05-03 22:07:47 发布

阅读量2.6k

点赞数 1

分类专栏： Qt 文章标签： qt 开发语言

原文链接：https://blog.csdn.net/u014779536/article/details/111029600

版权

Qt 专栏收录该内容

175 篇文章 12 订阅

订阅专栏

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

QList使用总结

============================================

QList使用总结

https://blog.csdn.net/zhengyanan815/article/details/127083087

概述

QList是Qt的泛型容器类之一。它将项目存储在一个列表中，该列表提供基于索引的快速访问以及基于索引的插入和删除。
QList、QLinkedList 和 QVector 提供了类似的 API 和功能。它们通常是可互换的，但性能有所区别。

QVector 应该是默认首选的容器
QList是最广泛用于Qt API中传递值的容器
QList不是指针结构体类型的链表，真正的结构体指针链表是 QLinkedList

一、QList 声明及初始化

QList可以保存基本数据类型的，如int，double，bool等；但是在存储QObject对象及其子类对象时，不能直接存对象本身，而是只能存对象的地址；

1. 声明 QList
声明简单：

    //基本数据类型
    QList<int> integerList;
    QList<QDate> dateList;

    //存储QObject对象的地址
    QList <QWidget *> ptr_widgets;
    QList <QObject *> ptr_objects;

2. 初始化 QList

初始化也很简单；若没初始化，链表默认为空的。

    QList<QString> list = { "one", "two", "three" };

    QWidget * widget1 = new QWidget();
    QWidget * widget2 = new QWidget();
    QList<QWidget *> ptr_widgets = {widget1, widget2};

二、QList 基本的增加、删除、移动、修改

QList 在有些实现都是需要多个基本操作组合来实现的，不同的实现用的方法也不一致，Qt提供的都是最核心、最单一的功能。

1. 增加节点

insert()：插入节点到
append()：尾部添加节点
prepend() ：头部添加节点
operator <<()：尾部添加节点或链表
operator+=()：尾部添加节点

2. 删除节点

removeAt()：删除节点
removeFirst()：删除头节点
removeLast()：删除尾节点

3. 移动节点

move()：链表内移动节点位置
swap()：俩个链表交换值（其实交换一下地址映射就能实现）

4. 修改节点值

replace()：替换链表内的节点值

三、QList 定位节点

QList是有序的链表，可以通过索引来得到

operator [ ] 数组索引符：这个和普通数组一样的使用 [ ] 访问下标方法一致
at() 函数：也是通过索引值，也即是下标方式
Qt 推荐使用at()函数，这样的效率更好，因为 at（）函数不会发生深拷贝，而另外一种方式会。

QList还提供了一些快捷的索引 + 返回索引节点 + 删除原索引节点，也就是组合的功能；但是这个是 take…不是get…这样的，这就意味着，这个其实是✂剪掉一个节点，并返回

takeAt()：取得在指定位置的节点
takeFirst()：取得头节点；等价【takeAt（0）】
takeLast()：取得尾节点

四、QList 的基本信息

contains()：是否包含节点xxx
count()：对指定节点值计数
isEmpty()：链表为空？
size()：链表大小？
indexOf()：节点位置？

————————————————
版权声明：本文为CSDN博主「蚂蚁取经」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhengyanan815/article/details/127083087

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

文章目录

            1. 简介
            2. 使用示例
            3. 官方手册
            4. Member Function Documentation

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();
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65

执行结果：
在这里插入图片描述
程序说明：

添加元素

QList<QString> list;
list << "aa" << "bb" << "cc"; // 插入项目

1
2

赋值操作

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

    1
    2
    3
    4
    5

注意：从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);

    1
    2
    3
    4
    5
    6

注意：从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]

    1
    2
    3
    4
    5

注意：从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

    1
    2
    3
    4
    5
    6

此函数要求值类型具有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"]

    1
    2
    3
    4

另参见append(), prepend(), replace(), 和removeAt().

QList::iterator QList::insert(QList::iterator before, const T &value)

这是一个重载函数。
在迭代器之前指向的项目前面插入值。返回指向插入项的迭代器。注意，调用后传递给该函数的迭代器将无效。应该使用返回的迭代器代替。

bool QList::isEmpty() const