精华内容
下载资源
问答
  • 2019-12-03 21:46:19

    目录

    1、增加

    2、删除

    3、改

    4、查找

    5、取值

    6、转换

    7、测试代码


    QList是指针数组,当泛型小于等于4字节,直接存值,反之存对象的地址。

    1、增加

    //创建
    QList<int> list;
    for(int i = 0; i < 5; ++i)    list << i +1;
    QList<int> myList;
    
    //增加
    myList << 2;        //可以传值,可以传同类型的链表
    myList.append(3);   //可以传值,可以传同类型的链表
    myList.push_back(4);//在链表最后插值
    myList.prepend(1);      //在链表首地址插值、
    myList.push_front(0);   //在链表首地址插值、
    qDebug() << myList;
    
    //插值
    myList.clear();
    myList.insert(0,2);     //在位置0,插入数字2
    myList.insert(myList.begin(),1); //在链表起始位置插入数字1
    qDebug() << myList;

    2、删除

    //删除
    myList.clear();
    myList << list;
    myList.erase(myList.begin()); //删除某一位置的元素
    qDebug() << myList;
    myList.erase(myList.begin(),myList.end());//删除链表某一区间的元素
    qDebug() << myList;
    
    //删除某值
    myList.clear();
    myList << list;
    myList.removeAt(2);     //删除位置2上的元素
    qDebug() << myList.removeAll(2);    //删除值为2的元素,成功返回1
    qDebug() << myList.removeOne(4);    //删除元素4
    myList.removeLast();        //删除第一个元素
    myList.removeLast();        //删除最后一个元素
    qDebug() << myList;
    
    //删除并返回元素值
    myList.clear();
    myList.append(list);
    qDebug() << myList.takeAt(0);   //取出位置0上的元素,并返回它的值
    qDebug() << myList.takeFirst(); //取出第一个元素,并返回它的值
    qDebug() << myList.takeLast();  //取出最后一个元素,并返回它的值

    3、改

    //改
    myList.clear();
    myList << list;
    myList.replace(0,10);   //位置0上的元素,用10代替

    4、查找

    //查
    qDebug() << myList.indexOf(3,0); //从位置0开始查找元素3,返回元素位置
    qDebug() << myList.lastIndexOf(3,0); //从后向前数,位置0开始查找元素3.返回元素位置
    qDebug() << myList.endsWith(2); //判断,链表最后一个元素是否是2
    qDebug() << myList.startsWith(2); //判断,链表第一个元素是否是2

    5、取值

    //取值
    qDebug() << myList.front(); //链表第一个元素的值
    qDebug() << myList.first(); //链表第一个元素的值
    qDebug() << myList.last(); //链表最后一个元素的值
    qDebug() << myList.mid(1,3); //取位置1,后的3个元素

    6、转换

    //转换
    qDebug() << myList.toVector(); //返回一个vector对象
    qDebug() << myList.toSet(); //返回一个set对象
    std::list<int> stdList =  myList.toStdList(); //返回一个list对象
    qDebug() << stdList;
    
    //将std::list转为QList
    myList.clear();
    myList = QList<int>::fromStdList(stdList);
    
    //将QVector转为QList
    QVector<int> vec;
    for(int i = 0; i < 5; ++i) vec << i + 1;
    myList.clear();
    myList = QList<int>::fromVector(vec);
    qDebug() << myList;
    
    //将QSet转为QList
    QSet<int> set;
    for(int i = 0; i < 5; ++i) set << i + 1;
    myList.clear();
    myList = QList<int>::fromSet(set);
    qDebug() << myList;

    7、测试代码

    #include <QCoreApplication>
    #include <QDebug>
    #include <list>
    
    using namespace std;
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        //创建
        QList<int> list;
        for(int i = 0; i < 5; ++i)    list << i +1;
        QList<int> myList;
    
        //增加
        myList << 2;        //可以传值,可以传同类型的链表
        myList.append(3);   //可以传值,可以传同类型的链表
        myList.push_back(4);//在链表最后插值
        myList.prepend(1);      //在链表首地址插值、
        myList.push_front(0);   //在链表首地址插值、
        qDebug() << myList;
        //插值
        myList.clear();
        myList.insert(0,2);     //在位置0,插入数字2
        myList.insert(myList.begin(),1); //在链表起始位置插入数字1
        qDebug() << myList;
    
        //删除
        myList.clear();
        myList << list;
        myList.erase(myList.begin()); //删除某一位置的元素
        qDebug() << myList;
        myList.erase(myList.begin(),myList.end());//删除链表某一区间的元素
        qDebug() << myList;
    
        //删除某值
        myList.clear();
        myList << list;
        myList.removeAt(2);     //删除位置2上的元素
        qDebug() << myList.removeAll(2);    //删除值为2的元素,成功返回1
        qDebug() << myList.removeOne(4);    //删除元素4
        myList.removeLast();        //删除第一个元素
        myList.removeLast();        //删除最后一个元素
        qDebug() << myList;
    
        //删除并返回元素值
        myList.clear();
        myList.append(list);
        qDebug() << myList.takeAt(0);   //取出位置0上的元素,并返回它的值
        qDebug() << myList.takeFirst(); //取出第一个元素,并返回它的值
        qDebug() << myList.takeLast();  //取出最后一个元素,并返回它的值
    
        //改
        myList.clear();
        myList << list;
        myList.replace(0,10);   //位置0上的元素,用10代替
    
        //查
        qDebug() << myList.indexOf(3,0); //从位置0开始查找元素3,返回元素位置
        qDebug() << myList.lastIndexOf(3,0); //从后向前数,位置0开始查找元素3.返回元素位置
        qDebug() << myList.endsWith(2); //判断,链表最后一个元素是否是2
        qDebug() << myList.startsWith(2); //判断,链表第一个元素是否是2
    
        //取值
        qDebug() << myList.front(); //链表第一个元素的值
        qDebug() << myList.first(); //链表第一个元素的值
        qDebug() << myList.last(); //链表最后一个元素的值
        qDebug() << myList.mid(1,3); //取位置1,后的3个元素
    
        //转换
        qDebug() << myList.toVector(); //返回一个vector对象
        qDebug() << myList.toSet(); //返回一个set对象
        std::list<int> stdList =  myList.toStdList(); //返回一个list对象
        qDebug() << stdList;
    
        //将std::list转为QList
        myList.clear();
        myList = QList<int>::fromStdList(stdList);
    
        //将QVector转为QList
        QVector<int> vec;
        for(int i = 0; i < 5; ++i) vec << i + 1;
        myList.clear();
        myList = QList<int>::fromVector(vec);
        qDebug() << myList;
    
        //将QSet转为QList
        QSet<int> set;
        for(int i = 0; i < 5; ++i) set << i + 1;
        myList.clear();
        myList = QList<int>::fromSet(set);
        qDebug() << myList;
        return a.exec();
    }
    

     

    更多相关内容
  • 双重qlist用法

    2018-04-26 15:46:23
    当碰上需要QList套用QlList,即QList<QList>,结果往往无法预知,显示未知信息,但有时候就是想用双重list,如何做呢?本程序给出了示例。
  • 申明:不是原创,不是原创,只是转载。 这是一个来自网上的例子 ...用于测试QList的线程安全性,因原作者只给出源代码,没有给出测试结果,这里生成一个QT工程,打开即可编译,内部有ReadME.txt,简要说明
  • Qt容器类比较典型的就是QList,QMap,遍历器的使用分为STL风格和Java风格。
  • Qlist

    2019-07-22 16:33:29
    由于QList在链表两端都预先分配了缓存以应对链表两端的快速添加操作,这样就使得在QList的 两端插入或删除元素变得非常地快。 如果需要找出某个值在链表中出现的位置,我们可以使用indexOf()、lastIndexOf()...

    转自:https://blog.csdn.net/weixin_43542624/article/details/84289605

     
    1. #include "mainwindow.h"

    2. #include <QApplication>

    3. #include <QFile>

    4. #include <QString>

    5. #include <QDir>

    6. #include <QtCore>

    7. #include <QDebug>

    8. #include <QList>

    9.  
    10. int main(int argc, char *argv[])

    11. {

    12. QApplication a(argc, argv);

    13.  
    14. QList<QString> list;

    15. list<<"aa"<<"bb"<<"cc"; // 插入数据

    16. // 输出整个列表

    17. for(int i=0;i<list.size();i++){

    18. qDebug()<<list.at(i);

    19. }

    20. qDebug()<<"11********************************************************************11";

    21. list.replace(2,"dd"); // 替换,计数是从0开始的

    22. list.append("ee"); // 末尾添加

    23. list.prepend("dao"); // 表头添加

    24. // 输出整个列表

    25. for(int i=0;i<list.size();i++){

    26. qDebug()<<list.at(i);

    27. }

    28. qDebug()<<"22********************************************************************22";

    29. QString str=list.takeAt(2);// 删除,并获取到它(只是删除的话用removeAt())

    30. qDebug()<<"at(2) item is: "<<str;

    31. list.insert(2,"dao");

    32. for(int i=0;i<list.size();i++){

    33. qDebug()<<list.at(i);

    34. }

    35. qDebug()<<"33********************************************************************33";

    36. list.swap(1,3); // 交换

    37. qDebug()<<"now the list is:";

    38. // 输出整个列表

    39. for(int i=0;i<list.size();i++){

    40. qDebug()<<list.at(i);

    41. }

    42. qDebug()<<"44********************************************************************44";

    43. qDebug()<<"Containes dao?"<<list.contains("dao");// 是否包含dao

    44. qDebug()<<"the dao count:"<<list.count("dao"); // 个数

    45. qDebug()<<"the first dao index:"<<list.indexOf("dao");

    46. qDebug()<<"the second dao index:"<<list.indexOf("dao",1); // 指定位置1开始

    47. return a.exec();

    48. }

    结果输出:

     
    1. "aa"

    2. "bb"

    3. "cc"

    4. 11********************************************************************11

    5. "dao"

    6. "aa"

    7. "bb"

    8. "dd"

    9. "ee"

    10. 22********************************************************************22

    11. at(2) item is: "bb"

    12. "dao"

    13. "aa"

    14. "dao"

    15. "dd"

    16. "ee"

    17. 33********************************************************************33

    18. now the list is:

    19. "dao"

    20. "dd"

    21. "dao"

    22. "aa"

    23. "ee"

    24. 44********************************************************************44

    25. Containes dao? true

    26. the dao count: 2

    27. the first dao index: 0

    28. the second dao index: 2

    29. 程序异常结束。

    30. C:\Users\Administrator\Documents\1234-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug\debug\1234.exe 退出,退出代码: 62097

    31.  
    32. C:\Users\Administrator\Documents\1234-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug\debug\1234.exe 启动中...

    33. "aa"

    34. "bb"

    35. "cc"

    36. 11********************************************************************11

    37. "dao"

    38. "aa"

    39. "bb"

    40. "dd"

    41. "ee"

    42. 22********************************************************************22

    43. at(2) item is: "bb"

    44. "dao"

    45. "aa"

    46. "dao"

    47. "dd"

    48. "ee"

    49. 33********************************************************************33

    50. now the list is:

    51. "dao"

    52. "dd"

    53. "dao"

    54. "aa"

    55. "ee"

    56. 44********************************************************************44

    57. Containes dao? true

    58. the dao count: 2

    59. the first dao index: 0

    60. the second dao index: 2

    61. QList是一种表示链表的模板类。
      QList<T>是Qt的一种泛型容器类。它以链表方式存储一组值,并能对这组数据进行快速索引,
      还提供了快速插入和删除等操作。
      QList、QLinkedList和QVector提供的操作极其相似:
      * 对大多数操作来说,我们用QList就可以了。其API是基于索引(index)的,因此用起来比QLinkedList更方便(QLinkedList的API是基于迭代器的)。QList比QVector更快,这是由它
      们在内存中的存储方式决定的。
      * 需要使用QLinkedList的地方:
      * 需要使用QVector的地方:元素的储存位置彼此相邻。

      QList<T>表示为一组指向被存储元素的数组。(例外,如果T本身就是指针类型,或者是size不
      大于指针类型的基本类型,或者是Qt的共享类,那么QList<T>会直接在指针数组中存储这些元素
      。)元素个数小于1000的QList能够很快地实现在链表中间插入操作,以及快速的查找操作。此
      外,由于QList在链表两端都预先分配了内存,因此实现prepend()和append()操作都很快。
      注意:对于size比指针大的共享类,使用QVector会更好。

      以下是两个分别存储int型数据和QDate类型数据的链表:
      QList<int> intList;
      QList<QDate> dateList;
      对于字符串链表,Qt提供了QStringList类。它继承自QList,但还提供了一些其他便于使用字符
      串的函数:QStringList::join()、QStringList::find()、QStringList::split()。

      QList以链表形式存储一组元素。默认为空链表,我们可以使用<<操作符添加元素:
      QList<QString> list;
      list << "one" << "two" << "three"; // list: ["one", "two", "three"]
      QList提供了一系列添加、移动、删除元素的操作:insert(), replace(), removeAt(), swap()
      。此外,它还提供了便于操作的函数:append(), prepend(), removeFirst(), removeLast()。
      QList与C++中数组的索引方式一样,都是从0开始的。我们可以使用[]操作符来访问位于索引值
      处的元素。对于非const链表,操作符[]返回的是该元素的引用,并且返回值可以用途左操作数。
      if ( list[0] == "Bob" )
         list[0] = "Robert";
      由于QList是以指针数组的形式实现的,该操作能够很快地实现(时间复杂度为常数)。对于只读
      访问,我们可以用at()函数实现访问:
      for ( int i=0; i!=list.size(); ++i )
      {
         if ( list.at(i) == "Jane" )
         { cout << "Found Jane at position:" << i<< endl;}
      }
      at()操作比操作符[]更快,因为它不需要深度复制(deep copy)。
      QList的一个常用操作是,从链表中取出一个元素(元素不再在链表之中),并对该元素进行操作。
      QList提供了以下操作来实现此功能:takeAt()、takeFirst()、takeLast()。以下是一个示例:
      QList<QWidget *> list;
      ...
      while ( !list.isEmpty() )
         deleta list.takeFirst();
      由于QList在链表两端都预先分配了缓存以应对链表两端的快速添加操作,这样就使得在QList的
      两端插入或删除元素变得非常地快。
      如果需要找出某个值在链表中出现的位置,我们可以使用indexOf()、lastIndexOf()函数来实现。
      前者进行前向查找,而后者则进行反向查找。两者都会在找到匹配元素后返回该元素的索引值。若
      没有找到匹配元素,则返回-1。例如:
      int i = indexOf("Jane");
      if ( i!=-1 )
         cout << "First occurance of Jane is at position" << i << endl;

      如果仅仅是想判断链表中是否包含某一值,我们可以使用函数contains()。如果希望知道某一值在
      链表中的出现次数,使用count()函数。如果要替换掉链表中所有值与某一值相同的元素,使用
      replace()。

      QList的值必须是可数的类型。这包含了我们常用的大多数类型。但是,如果我们存储QWidget类型
      的话,编译器也不会通知我们出错了。但是,我们应该使用QWidget *,而不是QWidget。此外,一
      些函数还作出了其它限制,比如:indexOf()和lastIndexOf()操作要求值的类型能进行“==”操作。

      为了提高效率,QList的成员函数在使用前并不会验证其参数是否有效。除isEmpty()函数外,其它
      成员函数都会假定该容器为非空容器;使用索引值(index)进行操作的成员函数都会假定其索引值参
      数是在有效范围内的。这就意味着,QList在有些时候会出错。如果在编译时,我们定义了QT_NO_DEBUG
      ,编译过程中就不会检测这些错误。如果没有定义QT_NO_DEBUG,我们可以利用Q_ASSERT()或者
      Q_ASSERT_X()加上一些合理的信息来实现错误检测。

      我们可以在调用其他函数之前先调用isEmpty()函数判断链表是否为空,以避免对空链表进行错
      误操作。而对于以索引值index为参数的成员函数,我们还需要判断该索引值是否位于有效范围

    展开全文
  • 三、Qt常用容器之QList

    千次阅读 2022-03-04 15:11:48
    1、QList介绍 介绍个锤子,有点累,摊牌了,这篇是水的,但是我觉得质量很高,因为我自己写不了这么详细,对,感谢某不知名网站编程指南,我直接白嫖,这篇实在是太多了,说句实话日常使用不久存个指针,然后遍历...

    1、QList介绍

    介绍个锤子,有点累,摊牌了,这篇是水的,但是我觉得质量很高,因为我自己写不了这么详细,对,感谢某不知名网站编程指南,我直接白嫖,这篇实在是太多了,说句实话日常使用不久存个指针,然后遍历查找之类的,怎么能写这么多!

    在开始讲解 QList 之前,我们先明确一下 Qt 数据容器能存储什么,不能存储什么。
    Qt 提供的数据容器都是模板类,构造时要带数据类型,比如下面这句定义整型数列表:

    QList<int> integerList;

    Qt 数据容器有支持的数据类型,也有不支持的类型,不仅是 QList ,其他数据容器都有不支持的数据类型。
    存储在 Qt 数据容器里面的数据,必须是可赋值类型!
    比如 C++ 基本数据类型,int、double、指针等可以存储在 Qt 数据容器里;
    Qt 的数据类型,比如 QString、QDate、QTime 等,我们在 Qt Assistant 帮助文档里面查询 QDataStream 支持的可串行化的数值类型,关键字索引为“Serializing Qt Data Types”,这些基本都是可以存到 Qt 数据容器里面的。

    还有不能存储在数据容器里的:窗体 QWidget、对话框 QDialog、定时器 QTimer 等等, 凡是 QObject 类和所有 QObject 派生类的对象都不允许直接存储在数据容器里面 。如果代码里新建 QList 列表,那么编译器会报错,QWidget 的复制构造函数和赋值运算符 = 函数都是禁用的。因为窗口不算数据类型,窗口里有线程、指针、句柄、信号和槽函数等等非常复杂的东西,不能当普通数据类型使用。如果确实要存储窗口列表,那么只能存储指 针,比如 QList<QWidget >。
    **
    如果希望自定义数据类型能存储在 Qt 数据容器里面,那么自定义类型必须至少满足三个条件:
    ①定义默认构造函数,比如 MyData() ;
    ②定义复制构造函数,比如 MyData(const MyData &d);
    ③定义赋值运算符 = 函数,比如 MyData& operator=(const MyData &d)。
    *
    讲完可以存储和不能存储的类型之后,我们开始列表类 QList 的学习。

    QList 就是存储 T 类型数据的列表,类似 T 的数组,可以通过数据下标访问各个元素, QList 针对数据的插入、列表头部添加元素、列表尾部添加元素等等做过优化,访问也非常高效。 QList 应用非常广泛, QList 可以模拟队列操作,比如入队 append() ,出队 takeFirst();也可以模拟栈工作,比如入栈 append() ,出栈 takeLast();模拟数组就更简单了,直接用用下标形式,如 aList[0] 。

    2、构造函数

    (1)构造函数

    QList() //默认构造函数
    QList(const QList & other) //复制构造函数
    QList(QList && other) //移动构造函数
    QList(std::initializer_list args) //初始列表构造函数
    ~QList() //析构函数

    第一个是默认构造函数,不带任何参数,可以支持嵌套的列表或与其他数据容器嵌套。
    第二个是复制构造函数,将 other 里面的元素均复制到新对象里面。
    第三个是 C++11 新特性,配合 std::move 语句使用,将 other 里面的元素全部移动给新建对象,other 本身清空。
    第四个也是 C++11 新特性,使得列表对象可以用大括号列举元素初始化,比如 {1, 3, 6, 8} 可以用于初始化整型数列表。
    项目里启用 C++11 特性,需要在 *.pro 项目文件里添加一行配置代码:

    CONFIG += c++11

    3、插入函数

    void append(const T & value)
    void append(const QList<T> & value)
    void push_back(const T & value) //同第一个 append(),STL风格添加到队尾

    append() 是追加元素到列表的末尾,第一个追加函数添加一个元素到列表末尾,第二个追加函数将一个列表中所有元素追加到列表末尾。

    void insert(int i, const T & value)

    插入函数将 value 插入到序号为 i 的位置,如果 i 为 0,元素插到列表列头部,如果 i 为 size() 数值,那么元素添加到列表末尾。

    void prepend(const T & value)
    void push_front(const T & value) //STL风格,同 prepend()

    prepend() 是将参数里的元素 value 添加到列表头部,等同于 insert(0, value) 。

    4、删除和移动类函数

    移除函数和删除函数调用之前都要判断列表是否非空,用 ! empty() 或 ! isEmpty() 判断,带有序号 i 的必须保证序号不越界。

    T takeAt(int i) //移除序号为 i 元素并返回该元素
    T takeFirst() //移除队头元素并返回该元素
    T takeLast() //移除队尾元素并返回该元素

    take**() 移除函数只是将元素从列表中卸载下来,并不会删除元素内存空间,卸下来的元素作为返回值返回。

    void removeAt(int i) //删除序号为 i 的元素,释放该元素内存
    void removeFirst() //删除队头元素,释放该元素内存
    void pop_front() //同 removeFirst() ,STL风格
    void removeLast() //删除队尾元素,释放该元素内存
    void pop_back() //同 removeLast(),STL风格

    remove**() 函数没有返回值,直接从列表删除元素,并释放该元素内存空间,删除的元素彻底消失。

    int removeAll(const T & value) //删除列表中所有等于 value 值的元素,返回删除的数量
    bool removeOne(const T & value) //删除列表中第一个等于 value 值的元素,如果列表有等于 value 值的元素,返回 true,否则返回 false

    注意 removeAll( value ) 函数不是清空列表,而是删除列表中所有等于 value 值的元素,并返回删除的计数。
    removeOne( value ) 函数第一个等于 value 值的元素,如果删除成功返回 true,即列表中存在等于 value 的元素,
    如果删除失败返回 false,即列表中不存在等于 value 的元素。需要特别注意的是:
    removeAll( value )、removeOne( value )这两个函数必 须要类型 T 存在 operator==() 等于号函数,T 类型能够进行相等判断!

    void clear()

    clear() 函数才是删除列表所有元素,并释放内存空间。

    5、访问和查询函数

    ``int size() constint length() const //同 size()

    获取列表大小,即存储的元素总数量。列表有 size() 函数,但是没有 resize() 函数,不能直接扩展列表大小。
    列表只有为新元素提前保留空间的函数:

    void reserve(int alloc)

    reserve() 函数是在程序员能够提前预估元素总量的情况提前为 alloc 数量的元素申请内存空间,保留使用。
    如果 alloc 数值不超过 size() 数值,该函数调用被忽略;如果 alloc 数值大于 size() 数值,那么提前分配空间,保证列表能够存储 alloc 数量的元素。注意 reserve() 函数不会改变列表 size() 数值大小,不会添加任何新元素,仅仅是调整内部存储空间,保留使用,实际并没有使用新分配的空间,列表内的元素个数不变。
    列表有两个 count() 计数函数,用途不一样:

    int count(const T & value) const
    int count() const

    第一个 count( value ) 函数统计列表中等于 value 值的元素个数,这个函数也需要类型 T 带有 operator==() 等于号函数。
    第二个 count() 函数不带参数,等同于 size() 函数,是列表元素的总数量。

    判断列表是否为空列表,使用如下函数:

    bool empty() const //空列表返回 true,有元素就返回 false,STL风格
    bool isEmpty() const //空列表返回 true,有元素就返回 false ,Qt 风格

    注意 empty() /isEmpty() 、size()/length()/count() 函数要牢记经常使用,因 为列表的函数,凡是涉及到序号 i 的,绝大部分函数都不会判断序号 i 是否越界,需要程序员手动判断序号 i 是否越界,列表的很多函数并不安全!
    列表函数为了优化访问效率,基本上没有为访问序号 i 的函数添加越界判断,所以一旦越界,程序很可能崩溃!

    访问序号为 i 的元素,可以使用如下函数:

    const T & at(int i) const

    at( i ) 函数返回序号为 i 元素的只读引用,但是不 进行数组越界 判断,需要手动判断,该函数的好处是读取效率高。
    比较安全的访问函数是下面两个:

    T value(int i) const
    T value(int i, const T & defaultValue) const

    第一个 value( i ) 函数返回 序号为 i 的元素(数值复制,不是引用),如果 i 越界,那么返回 T 类型默认构造函数生成的数值,比如 int、double、指针 都返回 0(Qt 容器为基本数据类型做了初始化)。
    第二个 value( i, value ) 原理是类似的, i 不越界就返回该序号元素值,越界就返回参数里指定的 value 值。
    两个 value() 函数因为每次调用都进行数组越界判断,所以访问效率不如 at() 函数高,在知道不越界的情况下使用 at() 更好。

    查询数组里是否包含某个数值元素,使用如下函数:

    bool contains(const T & value) const

    如果包含等于 value 值的元素返回 true,否则返回 false。要统计等于 value 值的元素个数,使用前面的 count( value ) 函数。
    如果希望查询等于 value 值的元素的序号,

    int indexOf(const T & value, int from = 0) const //从前向后 查找等于 value 值的元素序号
    int lastIndexOf(const T & value, int from = -1) const //从后向前查找等于 value 值的元素序号

    indexOf( value, from ) 是从前向后查找元素,第一个参数是要匹配的数值,第二个是查询的起始最小序号,默认从 0 序号开始查找。
    lastIndexOf( value, from ) 是从后向前查找元素,第一个参数是要匹配的数值,第二个是查询的起始最大序号,默认从队尾开始查找。
    这两个查询函数,如果没找到匹配元素就返回 -1,如果找到了就返回值正确的序号。
    注意 contains( value )、count( value ) 、indexOf( value, from )、lastIndexOf( value, from ) 函数都要求 T 类型支持 operator==() 等于号函数。

    判断队头、队尾元素是否为 value 的函数如下:

    bool startsWith(const T & value) const //检查队头是否等于 value
    bool endsWith(const T & value) const //检查队尾是否等于 value

    startsWith( value ) 检查队头元素,如果等于 value 就返回 true,如果列表为空或队头不等于 value 返回 false。
    endsWith( value ) 检查队尾元素,如果等于 value 就返回 true,如果列表为空或末尾不等于 value 返回 false。

    获取列表头部、尾部元素引用的函数如下:

    T & first() //队头读写引用,可以修改队头数值
    const T & first() const //队头只读引用
    T & front() //队头读写引用,可以修改队头数值,STL风格
    const T & front() const //队头只读引用,STL风格
    T & last() //队尾读写引用,可以修改队尾数值
    const T & last() const //队尾只读引用
    T & back() //队尾读写引用,可以修改队尾数值,STL风格
    const T & back() const //队尾只读引用,STL风格

    注意区分只读引用和读写引用,只读引用不会改变元素的数值,而读写引用可以修改队头或队尾的数值。
    上面获取队头、队尾引用的 8 个函数本身没有进行列表数组非空判断,在调用它们之前,
    必须手动用 ! empty() 或 ! isEmpty() 判断列表非空之后才能调用上面 8 个函数。

    获取列表的子列表,使用如下函数:

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

    mid() 函数新建一个子列表,将本列表从序号 pos 开始位置,复制长度为 length 数量的元素到子列表中并返回。
    如果 length 为 -1(或大于后面剩余的元素数量),就返回从 pos 开始的所有元素列表。返回的子列表是独立的新列表,与本列表没有内存共享。

    6、替换、移动和交换函数

    替换函数就是赋值修改:

    void replace(int i, const T & value) // 等同于 list[i] = value;

    将 序号为 i 的元素数值修改为新的 value。注意序号 i 不能越界,必须满足 0 <= i < size() 。

    void move(int from, int to)

    move(from, to) 移动函数是将序号 from 的元素移动到序号为 to 的位置,就是先卸载 from 序号元素,然后插入到 to 序号位置。
    两个序号必须都位于 0 到 size() 之间,序号必须合法。

    void swap(QList<T> & other)

    这是大 swap() 函数,将本列表所有元素与参数 other 列表内所有元素互换,这个函数不会出错,并且互换的效率非常高。

    void swap(int i, int j)

    第二个是小 swap() 函数,将序号 i 的元素和序号 j 的元素数值互换,序号 i、j 不能越界,必须合法。

    7、运算符函数

    我们设置三个简单整数列表,在表格中举例说明各个运算符函数用途。三个列表如下:

    QList<int> aList = {1, 3, 5};
    QList<int> bList = {2, 4, 6};
    QList<int> cList;

    上面使用 C++11 初始列表构造了列表 aList 和 bList ,cList 是空列表。各个运算符函数举例如下表:

    运算符函数举 例描述
    bool operator!=(const QList<T> & other) constaList != bList ;aList 和 bList 两个列表有元素不同,结果为 true。
    QList<T> operator+(const QList<T> & other) constcList = aList + bList;aList 和 bList 复制拼接后生成新列表,赋值给 cList。
    QList<T> & operator+=(const QList<T> & other)aList += bList ;复制 bList 所有元素追加到 aList 末尾。
    QList<T> & operator+=(const T & value)aList += 100 ;添加一个元素 100 到 aList 末尾。
    QList<T> & operator<<(const QList<T> & other)aList<<bList;复制 bList 所有元素追加到 aList 末尾。
    QList<T> & operator<<(const T & value)aList<<100;添加一个元素 100 到 aList 末尾。
    QList<T> & operator=(const QList<T> & other)cList = aList;aList 所有元素都复制一份给 cList,aList本身不变。二者相等。
    QList & operator=(QList<T> && other) //移动赋值cList = std::move(aList) ;aList 所有元素都移动给 cList,aList本身被清空。
    bool operator==(const QList<T> & other) constaList == bList ;aList 和 bList 有元素不同,结果为 false。 只有两个列表所有元素相等并且顺序一样,它们才能算相等。
    T & operator[](int i)aList[0] = 100;获取序号为 i 的元素的读写引用,可修改列表元素。
    const T & operator[](int i) constqDebug()<<aList[0] ;获取序号为 i 的元素的只读引用。

    这里说明一下:operator==() 函数需要左右两个列表的长度、每个序号对应元素全部都相同才返回 true,两个列表的元素次序也都要求一样。列表的等于号函数和不等于号函数都要求元素类型 T 必须有 operator==() 判断各个元素是否相等。
    移动赋值与移动构造类似,都是 C++11 的新特性,需要使用 std::move 语句实现,移动后右边列表会被清空,元素只存在左边列表里。
    中括号函数(数组下标访问函数)要求序号 i 必须合法, 0 <= i < size() ,如果序号越界,程序会崩溃。

    8、迭代器函数

    QList 内嵌了 STL 风格的只读迭代器和读写迭代器:

    QList::const_iterator //只读迭代器类,STL风格
    QList::iterator //读写迭代器类,STL风格
    QList::ConstIterator //只读迭代器,Qt命名风格
    QList::Iterator //读写迭代器,Qt命名风格

    迭代器就像指向元素的指针,可以枚举列表中所有元素,迭代器本身支持各种操作符函数,
    比如 ++ 是找寻下一个元素,-- 是倒退一个元素, (* it) 是获取元素。Qt 帮助文档中示范了迭代器的使用:

    QList<QString> list;
    list.append("January");
    list.append("February");
    ...
    list.append("December");

    QList<QString>::const_iterator i;
    for (i = list.constBegin(); i != list.constEnd(); ++i)
    cout << *i << endl;

    上述代码定义了一个字符串列表,为字符串列表添加多个字符串,然后定义字符串列表的迭代器 i;
    i 从列表头部迭代器开始,逐个遍历列表元素,打印每个字符串,直到迭代器末尾结束。
    list.constBegin() 是指向队头元素的指针,但是注意 list.constEnd() 是指向队尾后面假想元素的指 针,
    list.constEnd() 指向的东西根本不存在,仅用于越界判断。

    获取指向队头、队尾假想元素的只读迭代器函数如下:

    const_iterator begin() const //指向队头迭代 器,STL风格
    const_iterator cbegin() const //指向队头迭代器,STL风格
    const_iterator constBegin() const //指向队头迭代器,Qt命名风格
    const_iterator end() const //指向队尾假想元素迭代器,STL风格
    const_iterator cend() const //指向队尾假想元素迭代器,STL风格
    const_iterator constEnd() const //指向队尾假想元素迭代器,Qt命名风格

    获取指向队头、队尾假想元素的读写迭代器函数如下:

    iterator begin() //指向队头迭代器,STL风格
    iterator end() //指向队尾假想元素迭代器,STL风格

    利用迭代器也可以添加元素或删除元素,通过迭代器插入元素的函数如下:

    iterator insert(iterator before, const T & value) //在 before 指向的元素前面插入元素 value

    这个 insert() 函数需要注意两点:第一是返回值的迭代器指向新增元素 value ;
    第二是执行插入元素操作后,参数里的迭代器 before 失效,不能再使用,只能利用返回值的迭代器进行遍历。
    通过迭代器删除一个元素或多个元素的函数如下:

    iterator erase(iterator pos) //删除 pos 指向的元素,返回指向下一个元素的迭代器或者 list.end()
    iterator erase(iterator begin, iterator end) //删除从 begin 到 end 指向的元素,注意 end 指向的元素不删除

    第一个 erase() 函数删除单个元素,它的返回值可能为指向下一个元素或者 list.end() ,要注意判断是否为指向队尾假想元素的迭代器。
    第二个 erase() 函数删除多个元素,从 begin 删除到 end,但是 end 指向的元素不删除,这个函数总是返回参数里的 end 迭代器。
    由于 QList 自身带有非常多的功能函数,并且支持数组下标形式的访问,实际中几乎不需要使用迭代器操作 QList。因为用迭代器不如用数组下标来操作简单快捷。

    9、容器类型转换函数

    列表支持将自身对象转换为其他容器类型,比如集合、标准库列表、向量:

    QSet<T> toSet() const //转为集合
    std::list<T> toStdList() const //转为标准库的列表
    QVector<T> toVector() const //转为向量

    QList 能够转出,也能使用列表的静态成员函数,把其他三种容器转换为新的列表对象:

    QList<T> fromSet(const QSet<T> & set) //静态函数,将集合转为列表
    QList<T> fromStdList(const std::list<T> & list) //静态函数,将标准库列表转为 Qt 列表
    QList<T> fromVector(const QVector<T> & vector) //静态函数,将向量转为列表

    静态成员函数的语法类似下面这样:

    QVector v = {1, 2, 3};QList<int> cList = QList<int>::fromVector(v);

    (9)其他内容
    QList 附带了友元函数 operator<<() 和 operator>>(),用于支持数据流输入和输出:

    QDataStream & operator<<(QDataStream & out, const QList<T> & list)
    QDataStream & operator>>(QDataStream & in, QList<T> & list)

    这些流操作符函数正常运行的前提是 类型 T 也能支持流的输入输出,对于 C++ 基本类型 int、double 等都没问题;
    Qt 的数据类型如 QColor、QPoint 一般也都附带了友元函数,用于支持流输入输出。
    如果使用自定义类型,希望存储在列表中并支持自动的流输入输出,那么要为自定义类型添加友元函数 operator<<() 和 operator>>() 。

    使用 QList 时,需要注意 QList 仅支持存储 值类型、指针类型,不能存储变量的引用。
    如果定义列表时类型 T 设置为引用,如 QList<int &> ,那么程序无法编译!

    Qt 带有全局函数,可以支持容器类对象的排序:

    void qSort(Container & container) //排序
    void qStableSort(Container & container) //稳定排序

    排序函数要求容器的元素类型 T 必须支持 operator<() 小于号函数,用于比较元素大小。
    Qt 调用的小于号函数原型是两个参数的全局 operator<() 函数,不是成员函数,应该在类外面声明并定义下面的小于号函数:

    bool operator< ( const T &t1, const T &t2 )

    一般要将该函数声明为 T 类型的友元函数,方便访问私有变量。

    最后我们梳理一下,如果自定义类型希望能够完美地和 QList 配合使用,那么需求如下:
    ① 必须是可赋值类型,需要默认构造函数、复制构造函数、赋值函数 operator=() ;
    ② 如果希望支持查询函数,需要双等号函数 operator==();
    ③ 如果希望支持排序函数,需要全局小于号函数 operator< ( const T &t1, const T &t2 ) ;
    ④ 如果希望支持 QDataStream 数据流输入输出,那么添加友元函数 operator<<() 和 operator>>() 。
    第一条是必须实现的函数,后面三条是建议实现的函数。

    展开全文
  • Qt容器:QList

    千次阅读 2021-07-22 12:16:08
    QList<T> 是 Qt 的通用容器类之一。它将其项目存储在相邻的内存位置并提供基于索引的快速访问。QVector<T> 在 Qt 5 中曾经是一个不同的类,但在Qt6它是 QList 的一个别名。 QList<T> 和 ...

    一、描述

    QList<T> 是 Qt 的通用容器类之一。它将其项目存储在相邻的内存位置并提供基于索引的快速访问。QVector<T> 在 Qt 5 中曾经是一个不同的类,但在Qt6它是 QList 的一个别名。

    QList<T> 和 QVarLengthArray<T> 提供类似的 API 和功能。它们通常可以互换。

    • QList 应该是默认首选。
    • QVarLengthArray 提供了一个在堆栈上保留空间的数组,但如果需要,可以动态地增长到堆上。用于通常较小的短寿命容器是很好的。

    由于隐式共享,使用非常量运算符和函数可能会导致 QList 对数据进行深度复制。

    QList 的值类型必须是可赋值的数据类型。这涵盖了大多数常用的数据类型,但编译器不会允许将 QWidget 存储为值(可以存储一个 QWidget *)。

    最大大小

    QList 的最大大小取决于体系结构。大多数 64 位系统可以分配超过 2 GB 的内存,典型限制为 2^63 字节。实际值还取决于管理数据块所需的开销。因此,可以预期最大大小为 2 GB 减去 32 位平台上的开销,以及 2^63 字节减去 64 位平台上的开销。可以存储在 QList 中的元素数是此最大大小除以存储元素的大小。

    内存不足的情况

    当内存分配失败时,QList 使用 Q_CHECK_PTR 宏,如果应用程序编译时带有异常支持,它会抛出 std::bad_alloc 异常。如果异常被禁用,则内存不足是未定义的行为。

    操作系统可能会对持有大量已分配内存的应用程序施加进一步限制,尤其是大的连续块。此类考虑、此类行为的配置或任何缓解措施超出了 Qt API 的范围。


    二、成员函数

    1、void replace(qsizetype i, QList::parameter_type value)

          void replace(qsizetype i, QList::rvalue_ref value)

    用值替换索引位置 i 处的项目。i 必须是列表中的有效索引位置(即 0 <= i < size())。

    2、插入数据

    QList::iterator insert(qsizetype i, QList::parameter_type value)
    QList::iterator insert(qsizetype i, QList::rvalue_ref value)

    在列表中的索引位置 i 处插入值。 如果 i = 0,则该值将添加到最前面。如果 i = size(),则将该值追加到列表中。

    对于大型列表,此操作可能很慢,因为它需要将索引 i 及以上的所有项目在内存中进一步移动一个位置。 如果想要一个提供快速 insert() 函数的容器类,请改用 std::list

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

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

    QList<double> list;
    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]

    QList::iterator insert(QList::const_iterator before, QList::parameter_type value)
    QList::iterator insert(QList::const_iterator before, QList::rvalue_ref value)

    重载函数。在之前的迭代器指向的项目前插入值。返回指向插入项的迭代器。

        QList<int> list;
        auto insertIt = std::back_inserter(list);
        for(int i = 0;i < 7;++i)
        {
            *insertIt = i;
            ++insertIt;
        }
        qDebug()<<list;
        auto it = list.begin();
        it += 3;
        qDebug()<<*it;
        auto it2 = list.insert(it,8);
        qDebug()<<list;
        qDebug()<<*it2;

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

    在迭代器之前指向的项之前插入值的 count 个副本。 返回指向第一个插入项的迭代器。

    3、template <typename Args> QList::reference emplaceBack(Args &&... args)

         template <typename Args> QList::reference emplace_back(Args &&... args)

    在容器的末尾添加一个新元素。这个新元素是使用 args 作为构造参数就地构造的。返回对新元素的引用。

    QList<QString> list{"one", "two"};
    list.emplaceBack(3, 'a'); //构造函数:QString(qsizetype size, QChar ch)
    qDebug() << list;  // list: ["one", "two", "aaa"]

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

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

    4、void prepend(QList::parameter_type value)

         void prepend(QList::rvalue_ref value)

         void push_front(QList::parameter_type value)

         void push_front(QList::rvalue_ref value)

    在列表的开头插入值。

    通常这个操作是比较快的。 QList 能够在列表数据的开头分配额外的内存并在该方向上增长,而无需在每个操作上重新分配或移动数据。 但是,如果想要一个在前面插入复杂度为O(1)的容器类,请改用 std::list

    5、构造函数

    QList()

    QList(const QList<T> &other)

    复杂度为O(1),因为 QList 是隐式共享的。 这使得从函数返回 QList 的速度非常快。 如果共享实例被修改,它将被复制(写时复制),这需要线性时间(O(n))。

    QList(QList<T> &&other)

    QList(InputIterator first, InputIterator last)

    使用迭代器构造。

    QList(std::initializer_list<T> args)

    QList(qsizetype size, QList::parameter_type value)

    构造一个初始大小为 size 元素的列表。每个元素都用value初始化。

    QList(qsizetype size)

    构造一个初始大小为 size 元素的列表。元素使用默认构造的值进行初始化。

    6、在末尾追加元素

    void append(QList::parameter_type value)

    此操作相对较快,因为 QList 通常分配比所需更多的内存,因此它可以增长而无需每次重新分配整个列表。

    void append(QList::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 append(const QList<T> &value)

    void append(QList<T> &&value)

    void push_back(QList::parameter_type value)

    void push_back(QList::rvalue_ref value)

    QList<T> & operator+=()

    7、QList::const_reference at(qsizetype i) const

          QList::const_reference operator[](qsizetype i) const

    不会深拷贝。

          QList::reference operator[](qsizetype i)

    使用非常量运算符会导致 QList 进行深拷贝。

    8、 begin() / cbegin()             constBegin() / constEnd()        end() / cend()   

    起始迭代器 / 常起始迭代器        尾迭代器 / 常尾迭代器。

             crbegin() / crend()

    反向迭代器。

        QList<int> list;
        list << 1<<2<<3;
        for(auto it = list.crbegin();it != list.crend();++it)
            qDebug()<<(*it);// 3 2 1

    9、qsizetype capacity()

    返回可以存储在列表中而不强制重新分配的最大项目数。

    此函数的唯一目的是提供一种微调 QList 内存使用的方法。通常很少需要调用此函数。如果想知道列表中有多少项应调用 size()。

    10、void clear()

    从列表中删除所有元素。但列表申请的内存还在。

        QList<ceshi> list;
        list << 1<<2<<3;
        qDebug()<<list.capacity();
        list.clear();
        qDebug()<<list.capacity();

    11、QList::const_pointer constData()

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

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

    12、const T & constFirst() / const T & constLast()   

    返回对列表中第一项 / 最后一项的常引用。

    13、template <typename AT> bool contains(const AT &value)

    是否包含值。此函数要求值类型具有 operator==() 的实现。

    14、template <typename AT> qsizetype count(const AT &value)

    返回值在列表中出现的次数。此函数要求值类型具有 operator==() 的实现。

    15、data()

    返回指向存储在列表中的数据的指针。

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

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

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

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

    在位置 i 插入一个新元素。这个新元素是使用 args 作为构造参数就地构造的。

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

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

    17、bool empty()

    提供此功能是为了兼容 STL。等价于isEmpty()。

    18、bool endsWith(QList::parameter_type value) / bool startsWith(QList::parameter_type value)

    此列表是否不为空且其最后一项 / 第一项 等于 value。

    19、 QList::iterator erase(QList::const_iterator pos)

            QList::iterator erase(QList::const_iterator begin, QList::const_iterator end)

    从列表中移除迭代器 pos 指向的项目,并返回一个迭代器到列表中的下一个项目。

    元素删除但未减少列表内存。

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

    为列表中的所有项目赋值。 如果 size 不同于 -1(默认值),则列表会预先调整为 size。

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

    21、first()、front() / last()、back()

    首个元素 / 最后一个元素。

    22、QList<T> first(qsizetype n) / QList<T> last(qsizetype n)

    返回包含此列表的前 n 个 / 后 n 个元素的子列表。

    23、template <typename AT> qsizetype indexOf(const AT &value, qsizetype from = 0)

    返回列表中第一次出现 value 的索引位置,从索引位置开始向前搜索。如果没有匹配项,则返回 -1。此函数要求值类型具有 operator==() 的实现。

    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

    24、template <typename AT> qsizetype lastIndexOf(const AT &value, qsizetype from = -1)

    返回列表中最后一次出现值的索引位置,从索引位置开始向后搜索。如果 from 是 -1(默认值),则搜索从最后一项开始。 如果没有匹配项,则返回 -1。此函数要求值类型具有 operator==() 的实现。

    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

    25、QList<T> mid(qsizetype pos, qsizetype length = -1)

    返回包含此列表中元素的子列表,从位置 pos 开始。 如果 length 为 -1(默认),则包含 pos 之后的所有元素; 否则包括 length 个元素(如果少于length个元素,则返回所有剩余元素)。

    26、void move(qsizetype A, qsizetype B)

    将A位置的元素移动到B位置。

    27、void pop_back() / void removeLast()

    删除列表中的最后一项,但未清理列表的空间。

    28、void pop_front() / void removeFirst()

    删除列表中的第一项,但未清理列表的空间。

    29、void remove(qsizetype i, qsizetype n = 1)

    从列表中移除 n 个元素,从索引位置 i 开始。但未清理列表的空间。

    30、template <typename AT> qsizetype removeAll(const AT &t)

    从列表中删除所有与 t 相等的元素。 返回删除的元素数。但未清理列表的空间。

    31、void removeAt(qsizetype i)

    等同于:remove(i);

    32、template <typename Predicate> qsizetype removeIf(Predicate pred)

    从列表中删除谓词 pred 为其返回 true 的所有元素。返回删除的元素数(如果有)。(删除返回某条件的元素)

        QList<int> list;
        list << 1<<2<<3<<4<<5<<6<<7<<8<<9;
    
        list.swapItemsAt(3,5);
        list.removeIf([](const int & value)
        {
            return value > 3;
        });
        qDebug()<<list;

    33、template <typename AT> bool removeOne(const AT &t)

    从列表中删除与 t 相同的第一个元素。返回元素是否实际上已被删除。

     34、void reserve(qsizetype size)

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

    如果事先知道列表有多大,则应调用此函数以防止重新分配和内存碎片。

    reserve() 保留内存但不改变列表的大小。所以应配合调用 resize()。

    35、void resize(qsizetype size)

    将列表的大小设置为 size。 如果 size 大于当前大小,则将元素添加到末尾;新元素使用默认构造值进行初始化。 如果 size 小于当前大小,则从末尾删除元素。

    resize() 不再缩小容量。要摆脱多余的容量,请使用squeeze()。

    36、void shrink_to_fit() / void squeeze()

    释放任何不需要存储项目的内存。通常很少需要调用此函数。

    37、QList<T> sliced(qsizetype pos, qsizetype n)

            QList<T> sliced(qsizetype pos)

    返回包含此列表的 n 个元素的子列表,从位置 pos 开始。

    38、void swapItemsAt(qsizetype i, qsizetype j) 【实用】

    将索引位置 i 的项目与索引位置 j 的项目交换。

    39、T takeAt(qsizetype i)

    移除索引位置 i 处的元素并返回它。

    等同于:

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

    40、QList::value_type takeFirst() / QList::value_type takeLast()

    删除列表中的第一项 / 最后一项并返回它。

    41、T value(qsizetype i)

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

    如果索引 i 超出范围,则该函数返回一个默认构造的值。

    如果确定 i 在范围内,可以使用 at() 代替,它返回常引用,稍微快一点。

    T value(qsizetype i, QList::parameter_type defaultValue)

    如果索引 i 超出范围,则函数返回 defaultValue。


    三、相关非成员

    1、template <typename T, typename AT> qsizetype erase(QList<T> &list, const AT &t)

    从列表列表中删除所有与 t 比较相等的元素。 返回删除的元素数。

    注意:与 QList::removeAll() 不同,t 不允许是对列表内元素的引用。如果不能确定,应获取 t 的副本并使用副本调用此函数。

    2、template <typename T, typename Predicate> qsizetype erase_if(QList<T> &list, Predicate pred)

    用法和 removeIf() 相似。

    展开全文
  • 文章目录一文总结Qt序列式容器类—QList一、QList简介二、QList使用方法三、QList常使用的成员函数(3-1)向QList中插入项(3-2)移除QList中的项(3-3)移动QList中的项(3-4)访问QList中的项(3-5)查找QList中的...
  • Qt的通用容器类之一QList类介绍

    千次阅读 2021-04-16 14:29:34
    QListQList类是一个提供列表的模板类,要使用这个类,头文件需要导入QList库: #include <QList> 在qmake.pro文件中加入QList类的支持: QT += core QList的派生类有:QByteArrayList, QItemSelection, ...
  • QList原理

    2022-04-10 15:50:22
    QList不同于std::list,QList根据容易元素类型的不同,采用不同的数据结构来处理,从而节省内存、提高效率。 QList的模板参数T大概分为两种情况: (1)如果T占用的内存较多 或 T占用内存少但有构造函数 QList将每个...
  • QList容器和 QLinkedList容器

    千次阅读 2022-03-27 16:10:54
    QList容器 和 QLinkedList容器 QList< T>是最常用的容器类。QList以列表形态存储并管理数据,并能进行基于快速索引的访问,也可以进行快速的数据删除操作。继承自QList类的子类有QItemSelection、QQueue、...
  • 文章目录1. 简介2. 使用示例3. 官方手册4....可以使用QList::append()和QList::prepend()在列表的两端添加项目,也可以使用QList::insert()在列表的中间插入项目。常用的QStringList继承自QList<QS
  • 【Qt】深度解析QVector和QList

    千次阅读 2022-03-17 21:35:40
    QVector和QList在实际开发中,如何选择这个问题,小生一直有这个疑问。无意间,在查阅资料时,发现了一篇分析得比较好的文章(文末有列出)。这篇文章的一些观点和数据也来源于该篇文章。 一、【QVector】解析 ...
  • QList(增删改查)示例

    千次阅读 2022-01-25 16:32:56
    注:访问QList中的值时,尽量采用value(int i),因为value查不到此值时会返回一个默认值0,而at(int i)则会引起崩溃,并且at返回的值不可修改,不便于后期对数据的处理 //定义QList变量 QList<QString> list; /*...
  • QList内存释放

    2020-12-21 14:28:28
    QList 的释放分两种情况:1.T的类型为非指针,这时候直接调用clear()方法就可以释放了,看如下测试代码#include#include#includeintmain(intargc, char*argv[]){ QCoreApplication a(argc, argv); typedef struct_...
  • QList和QVector速度比较

    2022-01-01 16:57:33
    测试QList和QVector的数据插入和删除的速度。 代码如下(示例): //以函数对象的形式定义查找规则--升序--MftNumber class ascendingOrder { public: bool operator()(const int& i, const int& j) { ...
  • QList 和std::list的比较

    2021-01-19 02:55:16
    QList,QLinkedList,和QVector提供类似的功能,这里进行几点概述:1.大多数情况下,最好使用QList。它基于索引的API比QLinkedList基于迭代器的API方便。它存储数据的方式也使得它比QVector存取数据的数度快。而且它在...
  • Qt扫盲-QList使用总结

    千次阅读 2022-03-11 20:52:23
    QList使用总结概述一、QList 声明及初始化1. 声明 QList2. 初始化 QList二、QList 基本的 增加、删除、移动、修改1. 增加节点2. 删除节点3. 移动节点4. 修改节点值三、QList 定位节点四、QList 的基本信息五、QList ...
  • QList排序

    2021-09-06 10:17:11
    QList<int> rows {1, 21, 3, 6, 5, 6}; //std::sort(rows.begin(), rows.end());//从小到大 std::sort(rows.begin(), rows.end(), std::greater());//从大到小 for(int row : rows) { qDebug() ; } 输出 21 6 6 5 3...
  • <code class="language-cpp"> chart->legend()->hide(); chart->addSeries(series);...t call QList::first() on temporary [clazy-detaching-temporary]、 请问该怎么修改?</p>
  • 14-QList只读遍历

    千次阅读 2021-01-30 06:29:10
    QList相比。当对一个很大的列表进行插入操作,QLinkedList具有更高的效率。2.2.1.3 QVector 类QVector在相邻的内存中存储给定数据类型T的一组数组。在一个QVector的前部或者中间位置进行插入...
  • QList使用注意

    千次阅读 2020-07-16 13:14:44
    经过测试,Qlist.append函数,如果是append变量,都是append值传递进去的。 也就是说,想append一个变量进去是不行的,只能说是自己append这个变量的地址进去,这样就可以了 QList<int*> list; int a...
  • qlist 对结构体排序

    2021-12-29 18:21:37
    结构体排序:写法一QList<test> s; test aa; test bb; test cc; aa.num = "14"; bb...
  • QList的用法

    2021-08-25 17:26:02
    QList的用法 QList<VideoWidget *> videoWidget_list; VideoWidget *videoWidget = videoWidget_list.at(i)
  • QT6 的QList变化

    2020-10-24 10:47:08
    在这篇博客文章中,我试图捕捉对QList和相关类最重要的更改。 Q向量和QList是统一的 在此之前,Qt为这两个容器提供了非常不同的实现:QVector是一个自然而直观的类似数组的容器,而QList在其实现中非常特殊,以很...
  • QT使用QList获取差集

    2022-06-06 17:42:00
    qt使用QList获取差集

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,920
精华内容 6,768
关键字:

QLIST