QT容器

QString类

隐式共享:

隐式数据共享机制去最大化资源有效利用和最小化复制克隆操作。

隐式数据共享类当作为函数参数传递的时候，不仅安全而且效率很高，因为传递的时候只是传递了数据的指针，数据本身只当自己被修改的时候才会去复制。简称写时复制。

数据相同时，执行浅拷贝，仅复制指向数据块的指针，数据不同时则执行深拷贝。

隐式共享技术可以大大降低对内存的开销以及，CPU资源的消耗，很大程度提高应用程序的运行效率。

QString类保存了16位的Unicode值(宽字节)，Unicode把所有语言都统一到一套编码里，Unicode提供UTF-8、UTF-16、UTF-32编码方式。

UTF-8以字节为单位对Unicode进行编码，对不同范围的字体使用不同长度的编码。对于0x00-0x7F之间的字符，UTF-8编码与ASCII编码完全相同。

代码示例

1
2
3
4
5
6
7
8
QString s = "Hello";//Hello数据块引用计数为1
QString s1 = s;//Hello数据块引用计数为2
QString s2 = s;//Hello数据块引用计数为3
//其中一个进行球盖
s2 = "He";//不在引用Hello这个数据块，Hello数据块引用-1，He数据块引用计数为1
QString s3 = s;//Hello数据块引用计数为3
QString s4 = s2;//He数据块引用计数为2
QString s5 = s2;//He数据块引用计数为2

初始化

1
2
3
4
5
6
7
8
//const char* 初始化
QString s = "hello";
QString str("test");
//QChar数组初始化
QChar cHi[3] = {'h','i'};
QString strHi(cHi,2);Z
//类对象初始化
QString s1 = s;

转换

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
//QString转数字
  QString strAge("18");
  int nAge = strAge.toInt();//默认是10进制
  QString strRate("3.14");
  float nRate = strRate.toFloat();
  QString strDouble("3.333");
  double strD = strDouble.toDouble();
  //数字转QString
  int year = 2022;
  float height = 1.70f;
  QString strYear;
  strYear =  strYear.number(year);
  QString strHeight;
  strHeight = strHeight.number(height);
  QString strTest;
  strTest = strTest.setNum(year);
  //QString转QByteArray
  QString strTom = "Tom";
  QByteArray tomArray = strTom.toUtf8();
  const char* cTom = tomArray.data();
  //QString转QDataTime
  QString strTime = "1949-10-01 10:00:00";
  QDateTime dtTime = QDateTime::fromString(strTime,"yyyy-MM-dd hh:mm:ss");
  //QDateTime转QString
  QDateTime dtCurrent = QDateTime::currentDateTime();
  QString strCurrent = dtCurrent.toString("yyyy-MM-dd hh:mm:ss");

常用方法

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
//QString的拼接
    QString s = "对不起";
    s += "我是警察。";
    s.append("Sorry。");// 结尾添加
    //QString格式化
    QString s0;
    s0.sprintf("%s%d%s","我",19,"岁了。");
    QString s1;
    s1 = QString("%1%2%3").arg("我").arg(19).arg("岁了。");
    //以索引方式访问
    QChar qc1= s1.at(1);
    //插入字符
    QString s2= "我岁了。";
    QString s3 = "19";
    s2.insert(1,s3.toUtf8());
    //在字符串起始位置插入
    s2.prepend("今年");
    //指定位置进行替换
    s2.replace(0,2,"去年");
    //去除字符串两端的空格,中间的空格变为一个空格
    s2.trimmed();

    //查询字符
    QString s4 = "哔哩哔哩关注快乐的威猛先生";
    //查询是否以xx开头,BOOL
    qDebug()<<s4.startsWith("哔哩哔哩");
    QString s5 = "tom";
    qDebug()<<s5.startsWith("tom",Qt::CaseSensitive);//大小写敏感
    //查询是否以xx结尾
    qDebug()<<s5.endsWith("威猛先生");//同样可以表明大小写是否敏感
    //是否包含
   qDebug()<<s5.contains("o");//同样可以表明大小写是否敏感
   //比较
    qDebug()<<QString::compare("Tom","tom",Qt::CaseInsensitive);//判断字符串是否相等，大小写是否敏感
    //分割字符串
    QString strTime =  "2022/1/17";
    QStringList timeList = strTime.split("/");
    foreach (QString ss,timeList) {//循环读取容器中的元素，用一个变量来接收读取到的数据
       qDebug()<<ss;
    }
    //截取字符串
    QString sFriends = "EnvyuskenyS";
    qDebug()<<sFriends.mid(1,1);
    //判断NULL字符串isNull()，采用默认构造函数，或者用const char*xx ='\0'来对QString进行构造
	//判断空字符传isEmpty()

QStringList

QString类型的链表

常用操作。

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
 QStringList weekList;
 weekList<<"星期一"<<"星期二"<<"星期三"<<"星期四"<<"星期五"<<"星期六";
 weekList.append("星期天");//尾插
 qDebug()<<weekList;
 //for遍历链表
 for(int i = 0 ;i < weekList.size();i++)
 {
      qDebug()<<weekList.at(i);
 }
//foreach遍历链表
 foreach (QString ss, weekList) {
    qDebug()<<ss;
 }
 //STL风格迭代器
 QStringList::iterator it = weekList.begin();
 for(;it !=  weekList.end();it++)
 {
     qDebug()<<*it;
 }
 //JAVA风格迭代
 QListIterator<QString>itr(weekList);
 while (itr.hasNext()) {
     qDebug()<<itr.next();//java风格的迭代器初识位置在第一个元素的前一个位置
 }
 //查看链表中是否包含某个元素
 qDebug()<<weekList.contains("星期八");
 //插入元素
 weekList.insert(0,"星期零");
 weekList.append("星期八");
 //删除元素
 weekList.removeFirst();
 weekList.removeLast();
 weekList.removeOne("星期一");
 weekList.removeAt(0);
 weekList.clear();

QList

QList< T >是最常用的容器类。QList以列表形态存储并管理数据，并能进行基于快速索引的访问，也可以进行快速的数据删除操作。继承自QList类的子类有QItemSelection、QQueue、QStringList、QTestEventList.

可用运算符<< 、append()、prepend()进行添加元素，insert()进行插入。QList< T >维护了一个指针数组，数组元素指向每一个链表项，因此QList< T > 提供了基于下标的快速访问。

Java风格迭代器迭代点位置：第一个列表项前、两个列表项中间、最后一个列表项之后。STL风格迭代器迭代点位置：直接指向列表项。

image-20220117165954098

QString中可以通过[]来访问元素。因为里面放的是指针，通过指针访问元素。

相关操作示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
QList<int>list;
    //添加与元素
    list<<1<<2<<3<<4<<5;
    list.append(0);
    list.prepend(6);
    list.insert(0,99);
    //查找元素
   list.at(2);
   list[2];
    //查看是否包含
   list.contains(8);
    //修改元素
    list.replace(1,66);
    list[2] = 77;
    //删除元素
    list.removeFirst();
    list.removeLast();
    //删除指定位置元素
    list.removeAt(2);
    //指定元素删除
    list.removeOne(66);
    //清空链表
    list.clear();

迭代器

JAVA风格迭代器

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
//JAVA风格迭代器
   QList<int>montList;
   QMutableListIterator<int> it_mrw(montList);
   for(int i = 0 ; i <   12; i++)
   {
       it_mrw.insert(i);
   }
   //反遍历
   //将迭代器移到结尾，判断前面是否有数据
   for(it_mrw.toBack();it_mrw.hasPrevious();)
   {
       qDebug()<<it_mrw.previous();
   }
   //正遍历
   for(it_mrw.toFront();it_mrw.hasNext();)
   {
       qDebug()<<it_mrw.next();
   }
   //删除、修改
   for(it_mrw.toFront(); it_mrw.hasNext();)
   {
        int month = it_mrw.next();
        if(month== 0)
        {
             it_mrw.remove();
        }
        if(month == 11)
       {
             it_mrw.setValue(12);
       }

   }
   qDebug()<<montList;
   //只读迭代器
   QListIterator<int>it_mr(montList);
   //正遍历
   for(it_mr.toFront();it_mr.hasNext();)
   {
       qDebug()<<it_mr.next();
   }
   //反遍历
   for(it_mr.toBack();it_mr.hasPrevious();)
   {
       qDebug()<<it_mr.previous();
   }

STL风格迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 //STL风格迭代器
QList<int>numList;
numList<<10<<11<<12<<13;
//读写迭代器
 QList<int>::iterator it_numRW;
 for( it_numRW = numList.begin();it_numRW != numList.end();it_numRW++)
 {
     *it_numRW =*it_numRW *  10;
      qDebug()<<*it_numRW;
 }
 qDebug()<<"---";
 //只读迭代器
 QList<int>::const_iterator it_numR;
 //constEnd方法返回的迭代器指向最后一个元素之后，是虚拟的。
 for( it_numR = numList.constBegin();it_numR != numList.constEnd();it_numR++)
 {
         qDebug()<<*it_numR;
 }
   qDebug()<<"---";

QLinkedList

更加高效，大量数据情况下运行速度更快。是一个更加”纯粹”的链表。

不支持下标访问，不用维护那个指针数组。

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
QLinkedList<QString>weekList;
 for(int j = 1; j < 8 ;j ++ )
 {
      weekList<<QString("%1%2").arg("星期").arg(j);
 }
  //JAVA风格只读迭代器
  QLinkedListIterator<QString>it_wr(weekList);
  for(it_wr.toFront();it_wr.hasNext();)
  {
      qDebug()<<it_wr.next();
  }
  //Java风格读写迭代器
  QMutableLinkedListIterator<QString>it_wrw(weekList);
  for(it_wrw.toFront();it_wrw.hasNext();)
  {
      QString day = it_wrw.next();
      if(day == "星期3")
      {
          it_wrw.setValue("星期三");
      }
      if(day == "星期5")
      {
          it_wrw.setValue("星期五");
      }
      if(day == "星期6")
       {
          it_wrw.insert("星期六6");//插入到当前位置的后面
      }
  }
  for( it_wrw.toFront();it_wrw.hasNext();)
  {
       qDebug()<<it_wrw.next();
  }
  //QLinkedList不能支持下标访问

QVector

QVector在相邻的内存中存储给定数据类型T的一组数据。在QVector前部或中间位置插入操作速度都很慢，因为会导致内存中大量数据的移动。访问数据可使用下标，也可以使用迭代器。继承自QVector类的子类有QPolygon、QPolygonF、QStack。

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
QVector<QString>vStarts;
  //添加元素
 vStarts<<"星期1"<<"星期2"<<"星期3";
 vStarts.append("星期4");
 vStarts.prepend("星期5");
 vStarts.insert(0,"星期6");
 //修改元素
 vStarts.replace(0,"星期六");
 //删除元素
 vStarts.remove(0);
 vStarts.removeFirst();
 vStarts.removeAll("星期日");
 //访问元素
 vStarts[2];
 vStarts.at(2);
 vStarts.contains("星期日");
 //JAVA风格只读迭代
 QVectorIterator<QString>it_sr(vStarts);
 for(it_sr.toFront();it_sr.hasNext();)
 {
     qDebug()<<it_sr.next();
 }
 //JAVA风格读写迭代
 QMutableVectorIterator<QString>it_srw(vStarts);
 for(it_srw.toFront();it_srw.hasNext();)
 {
     QString s = it_srw.next();
     if(!QString::compare(s,"星期1"))
      {
         it_srw.setValue("星期一");
      }
 }
 qDebug()<<vStarts;

QMap

QMap与QHash差别：

  • QHash比QMap查找速度更快。
  • QHash以任意顺序存储，QMap以key顺序存储数据。
  • QHash的key必须提供operator==()及一个全局的qHash(key)函数，而QMap必须提供operator<()函数。

存储一键多值数据时可使用QMultiMap< key,T>容器或QMultiHash< key, T>容器

默认从小到大排序。

image-20220118110333932

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
66
67
68
69
70
71
72
QMap<QString,QString>infoMap;
 infoMap.insert("哈哈哈哈","鸡汤来喽");
 infoMap.insert("芜湖","起飞");
 infoMap["哔哩哔哩"]="快乐的威猛先生";
 infoMap["CSDN"]="半生瓜のblog";
 //通过key查找value
 qDebug()<<infoMap["哔哩哔哩"];
 //通过value找key
 qDebug()<<infoMap.key("快乐的威猛先生");
 //JAVA风格只读迭代器
 QMapIterator<QString,QString>it_r(infoMap);
 for(it_r.toFront();it_r.hasNext();)
 {
     it_r.next();
     qDebug()<<it_r.key()<<":"<<it_r.value();
 }
 //JAVA风格读写迭代器
 QMutableMapIterator<QString,QString>it_rw(infoMap);
 for(it_rw.toFront();it_rw.hasNext();)
 {
     it_rw.next();
     if(it_rw.key()=="哔哩哔哩")
      {
         it_rw.setValue("关注快乐的威猛先生");
     }
 }

  //STL风格只读迭代器
 QMap<QString,QString>::const_iterator i_r;
 i_r = infoMap.constBegin();
 for(;i_r != infoMap.constEnd();i_r++)
 {
     qDebug()<<i_r.key()<<":"<<i_r.value();
 }
 //STL风格读写迭代器
 QMap<QString,QString>::iterator i_rw;
 for(i_rw = infoMap.begin();i_rw != infoMap.end();i_rw++)
 {
        if(i_rw.key() == "哔哩哔哩")
        {
            i_rw.value() = "快关注威猛先生";
        }
 }
 i_rw = infoMap.find("哔哩哔哩");
 i_rw.value() ="bilibili";
 for(i_rw = infoMap.begin();i_rw != infoMap.end();i_rw++)
 {
     qDebug()<<*i_rw;//value
 }
 //一个键对应多个值
 QMultiMap<QString,QString>wMap1;//一个key对应多个value
 wMap1.insert("spring1","5°C");
 wMap1.insert("spring2","15°C");
 wMap1.insert("spring2","16°C");
 wMap1.insert("spring2","17°C");
 wMap1.insert("spring3","25°C");
 wMap1.insert("spring4","35°C");
 wMap1.insert("spring4","36°C");
 wMap1.insert("spring4","37°C");
 //指定元素删除
 wMap1.remove("spring1","5°C");
 //查询指定value
 wMap1.values("spring2");

 //JAVA风格只读迭代
 QMapIterator<QString,QString>it_r1(wMap1);
 for(it_r1.toFront();it_r1.hasNext();)
 {
     qDebug()<<it_r1.key()<<":"<<it_r1.next().value(); //这个迭代器看起来比较变扭，先拿key,然后通过下一个迭代点拿value
 }

 qDebug()<<wMap1;

QHash

无序。

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
//QHash类
  QHash<int,QString>moneyHash;
  moneyHash.insert(1,"一块钱");
  moneyHash.insert(10,"十块钱");
  moneyHash.insert(20,"二十块钱");
  moneyHash.insert(50,"五十块钱");
  moneyHash[50]  = "50";
  moneyHash.insertMulti(50,"50块钱");//插入多个value
  qDebug()<<moneyHash;
  //JAVA风格只读迭代器
  QHashIterator<int,QString>it_mr(moneyHash);
  for(it_mr.toFront();it_mr.hasNext();)
  {
      qDebug()<<it_mr.key()<<it_mr.next().value();
  }
  //JAVA风格读写迭代器
  QMutableHashIterator<int,QString>it_mrw(moneyHash);
  //修改数据
  if(  it_mrw.findNext("十块钱"))
  {
      it_mrw.setValue("10元");
  }
  for(it_mrw.toFront();it_mrw.hasNext();)
  {
      qDebug()<<it_mrw.key()<<":"<<it_mrw.next().value();
  }
  qDebug()<<moneyHash;

QVariant类

QVariant类能保存很多Qt类型的值，包括QColor,QBrush,QFont,QRect,QString及QSize等等，而且能存放Qt的容器类型值。

可采用toT()将QVariant对象转换为T类型数据并获取其值。如toInt()，toFloat(),toString(),可用type方法获取数据类型。对于GUI模块中定义的数据类型没有相应的转换函数，即没有toColor(),没有toImage()这样的函数提供，可通过value()方法实现转换，判断两种类型是否可以转换可通过用type方法获取数据类型，判断方法的返回值判断。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
QVariant vNum(100);
qDebug()<<vNum.toInt();
QVariant vPi(3.1415f);
qDebug()<< vPi.toFloat();
QVariant vStr("Hello");
qDebug()<<vStr.toString();
QVariant vb(true);
qDebug()<<vb.toBool();

QColor c = QColor(Qt::red);
QVariant VC = c;
qDebug()<<VC.type();
qDebug()<<VC.value<QColor>();

QVariant vss = vStr;
qDebug()<<vss.canConvert(QVariant::Int);//返回数据类型转换能力，QVariant的转换能力
qDebug()<<vss.convert(QVariant::Int);//false,转换失败，数据清空
//转换成功的条件:有转换能力，且数据类型匹配。