[Python知识库]第2章 Qt 5模板库、工具类及控件

一、字符串类

1、操作字符串

字符串有如下几个操作符。

（1）QString提供了一个二元的“+”操作符用于组合两个字符串，并提供了一个“+=”操作符用于将一个字符串追加到另一个字符串的末尾，例如：

QString str1 = "Welcome ";
str1=str1+"to you! ";        				//str1=" Welcome to you! "
QString str2="Hello, ";
str2+="World! ";             				//str2="Hello,World! "

其中，QString str1 = "Welcome ?"传递给QString一个const char*类型的ASCII字符串“Welcome”，它被解释为一个典型的以“\0”结尾的C类型字符串。这将会导致调用QString构造函数，来初始化一个QString字符串。其构造函数原型为：

QT_ASCII_CAST_WARN_CONSTRUCTOR QString::QString(const char* str)

被传递的const char*类型的指针又将被QString::fromAscii()函数转换为Unicode编码。默认情况下，QString::fromAscii()函数会将超过128的字符作为Latin-1进行处理（可以通过调用QTextCodec::setCodecForCString()函数改变QString::fromAscii()函数的处理方式）。

（2）QString::append()函数具有与“+=”操作符同样的功能，实现在一个字符串的末尾追加另一个字符串，例如：

QString str1 = "Welcome";
QString str2 = "to";
str1.append(str2);//str1="Welcome to"
str1.append("you!");//str1="Welcome to you!"

（3）组合字符串的另一个函数是QString::sprintf()，此函数支持的格式定义符和C++库中的函数sprintf()定义的一样。例如：

QString str;
str.sprintf("%s"," Welcome ");          				//str="Welcome "
str.sprintf("%s"," to you! ");           				//str="to you! "
str.sprintf("%s %s"," Welcome ", "to you! ");			//str=" Welcome to you! "

（4）Qt还提供了另一种方便的字符串组合方式，使用QString::arg()函数，此函数的重载可以处理很多的数据类型。此外，一些重载具有额外的参数对字段的宽度、数字基数或者浮点数精度进行控制。通常，相对于QString::sprintf()函数，QString::arg()函数是一个比较好的解决方案，因为其类型安全，完全支持Unicode，并且允许改变"%n"参数的顺序。例如：

QString str;
str=QString("%1 was born in %2.").arg("John").arg(1998);//str="John was born in 1998."

其中，"%1"被替换为"John"，"%2"被替换为"1998"。

（5）QString也提供了一些其他组合字符串的方法，包括如下几种。

① insert()函数：在原字符串特定的位置插入另一个字符串。

② prepend()函数：在原字符串的开头插入另一个字符串。

③ replace()函数：用指定的字符串代替原字符串中的某些字符。

（6）很多时候，去掉一个字符串两端的空白（空白字符包括回车字符“\n”、换行字符“\r”、制表符“\t”和空格字符“ ”等）非常有用，如获取用户输入的账号时。

① QString::trimmed()函数：移除字符串两端的空白字符。

② QString::simplified()函数：移除字符串两端的空白字符，使用单个空格字符“ ”代替字符串中出现的空白字符。 例如：

QString str="  Welcome \t to \n you!     ";
str=str.trimmed();                    				//str=" Welcome \t to \n you! "

2、查询字符串数据

（1）QString::startsWith()函数判断一个字符串是否以某个字符串开头。此函数具有两个参数。第一个参数指定了一个字符串，第二个参数指定是否大小写敏感（默认情况下，是大小写敏感的），例如：

QString str="Welcome to you! ";
str.startsWith("Welcome",Qt::CaseSensitive); 			//返回true
str.startsWith("you",Qt::CaseSensitive);      			//返回false

（2）QString::endsWith()函数类似于QString::startsWith()函数，此函数判断一个字符串是否以某个字符串结尾。

（3）QString::contains()函数判断一个指定的字符串是否出现过，例如：

QString str=" Welcome to you! ";
str.contains("Welcome",Qt::CaseSensitive);   			//返回true

（4）比较两个字符串也是经常使用的功能，QString提供了多种比较手段。

① operator<(const QString&)：比较一个字符串是否小于另一个字符串。如果是，则返回true。

② operator<=(const QString&)：比较一个字符串是否小于等于另一个字符串。如果是，则返回true。

③ operator==(const QString&)：比较两个字符串是否相等。如果相等，则返回true。

④ operator>=(const QString&)：比较一个字符串是否大于等于另一个字符串。如果是，则返回true。

⑤ localeAwareCompare(const QString&,const QString&)：静态函数，比较前后两个字符串。如果前面字符串小于后面字符串，则返回负整数值；如果等于则返回0；如果大于则返回正整数值。该函数的比较是基于本地（locale）字符集的，而且是与平台相关的。通常，该函数用于向用户显示一个有序的字符串列表。

⑥ compare(const QString&,const QString&,Qt::CaseSensitivity)：该函数可以指定是否进行大小写的比较，而大小写的比较是完全基于字符的Unicode编码值的，而且是非常快的，返回值类似于localeAwareCompare()函数。

3、字符串的转换

QString类提供了丰富的转换函数，可以将一个字符串转换为数值类型或者其他的字符编码集。 （1）QString::toInt()函数将字符串转换为整型数值，类似的函数还有toDouble()、toFloat()、toLong()、toLongLong()等。下面举个例子说明其用法：

QString str="125";					//初始化一个"125"的字符串
bool ok;
int hex=str.toInt(&ok,16);       				//ok=true,hex=293
int dec=str.toInt(&ok,10);       				//ok=true,dec=125

其中，int hex=str.toInt(&ok,16)：调用QString::toInt()函数将字符串转换为整型数值。QString::toInt()函数有两个参数。第一个参数是一个bool类型的指针，用于返回转换的状态。当转换成功时设置为true，否则设置为false。第二个参数指定了转换的基数。

（2）QString提供的字符编码集的转换函数将会返回一个const char*类型版本的QByteArray，即构造函数QByteArray(const char*)构造的QByteArray对象。QByteArray类具有一个字节数组，它既可以存储原始字节（raw bytes），也可以存储传统的以“\0”结尾的8位的字符串。在Qt中，使用QByteArray比使用const char*更方便，且QByteArray也支持隐式共享。转换函数有以下几种。

① toAscii()：返回一个ASCII编码的8位字符串。

② toLatin1()：返回一个Latin-1（ISO8859-1）编码的8位字符串。

③ toUtf8()：返回一个UTF-8编码的8位字符串（UTF-8是ASCII码的超集，它支持整个Unicode字符集）。

④ toLocal8Bit()：返回一个系统本地（locale）编码的8位字符串。

下面举例说明其用法：

QString str=" Welcome to you! ";			//初始化一个字符串对象
QByteArray ba=str.toAscii();//通过QString::toAscii()函数，将Unicode编码的字符串转换为ASCII码的字符串，并存储在QByteArray对象ba中。

qDebug()<<ba;//使用qDebug()函数输出转换后的字符串（qDebug()函数支持输出Qt对象）
ba.append("Hello,World! ");	//使用QByteArray::append()函数追加一个字符串。
qDebug()<<ba.data();			 	//输出最后结果

一个NULL字符串就是使用QString的默认构造函数或者使用“(const char*)0”作为参数的构造函数创建的QString字符串对象；而一个空字符串是一个大小为0的字符串。一个NULL字符串一定是一个空字符串，而一个空字符串未必是一个NULL字符串。例如：

QString().isNull();       				//结果为true
QString().isEmpty();      				//结果为true
QString("").isNull();     				//结果为false
QString("").isEmpty();   				//结果为true

二、容 ?器 ?类

????????这样的数据类型包含了通常使用的大多数数据类型，包括基本数据类型（如int和double等）和Qt的一些数据类型（如QString、QDate和QTime等）。不过，Qt的QObject及其他的子类（如QWidget和Qdialog等）是不能够存储在容器中的，例如： ? ?

QList<QToolBar> list;

上述代码是无法通过编译的，因为这些类（QObject及其他的子类）没有复制构造函数和赋值操作运算符。

一个可代替的方案是存储QObject及其子类的指针，例如： ? ?

QList<QToolBar*> list;

Qt的容器类是可以嵌套的，例如： ? ?

QHash<QString, QList<double> >

其中，QHash的键类型是QString，它的值类型是QList<double>。

Qt的容器类为遍历其中的内容提供了以下两种方法。

（1）Java风格的迭代器（Java-style iterators）。

（2）STL风格的迭代器（STL-style iterators），能够同Qt和STL的通用算法一起使用，并且在效率上也略胜一筹。

1、QList类、QLinkedList类和QVector类

在开发一个较高性能需求的应用程序时，程序员会比较关注这些容器类的运行效率。表2.1列出了QList、QLinkedList和QVector容器的时间复杂度比较。

1.1QList类

QList<T>是迄今为止最常用的容器类，它存储给定数据类型T的一列数值。继承自QList类的子类有QItemSelection、QQueue、QSignalSpy、QStringList和QTestEventList。

QList不仅提供了可以在列表中进行追加的QList::append()和Qlist::prepend()函数，还提供了在列表中间完成插入操作的QList::insert()函数。相对于任何其他的Qt容器类，为了使可执行代码尽可能少，QList被高度优化。

QList<T>维护了一个指针数组，该数组存储的指针指向QList<T>存储的列表项的内容。因此，QList<T>提供了基于下标的快速访问。

对于不同的数据类型，QList<T>采取不同的存储策略，存储策略有以下几种。

（1）如果T是一个指针类型或指针大小的基本类型（即该基本类型占有的字节数和指针类型占有的字节数相同），QList<T>会将数值直接存储在它的数组中。

（2）如果QList<T>存储对象的指针，则该指针指向实际存储的对象。

#include <QDebug>
int main(int argc,char *argv[])
{
	QList<QString> list;							//声明了一个QList<QString>栈对象
	{
		QString str("This is a test string");
		list<<str;				//通过操作运算符“<<”将一个QString字符串存储在该列表中。

	}	//程序中使用花括弧“{”和“}”括起来的作用域表明，此时QList<T>保存了对象的一个复制
	qDebug()<<list[0]<< "How are you! ";
	return 0;
}

1.2．QLinkedList类

QLinkedList<T>是一个链式列表，它以非连续的内存块保存数据。

QLinkedList<T>不能使用下标，只能使用迭代器访问它的数据项。与QList相比，当对一个很大的列表进行插入操作时，QLinkedList具有更高的效率。

1.3．QVector类

QVector<T>在相邻的内存中存储给定数据类型T的一组数值。在一个QVector的前部或者中间位置进行插入操作的速度是很慢的，这是因为这样的操作将导致内存中的大量数据被移动，这是由QVector存储数据的方式决定的。

QVector<T>既可以使用下标访问数据项，也可以使用迭代器访问数据项。继承自QVector类的子类有QPolygon、QPolygonF和QStack。

1.4．Java风格迭代器遍历容器

Java风格迭代器同STL风格迭代器相比，使用起来更简单方便，不过这也是以轻微的性能损耗为代价的。对于每一个容器类，Qt提供了两种类型的Java风格迭代器数据类型，即只读迭代器类和读写迭代器类，见表2.2。

Java风格迭代器的迭代点（Java-style iterators point）位于列表项的中间，而不是直接指向某个列表项。

下面以QList为例，介绍两种Java风格迭代器的用法。QLinkedList和QVector具有与QList相同的遍历接口，在此不再详细讲解。

（1）QList只读遍历方法。 【例】（简单）（CH201）通过控制台程序实现QList只读遍历方法。 其具体代码如下：

#include <QCoreApplication>	
#include <QDebug>					//头文件<QDebug>中已经包含了QList的头文件。
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);			//Qt的一些类，如QString、QList等，不需要QCoreApplication的支持也能够工作，但是，在使用Qt编写应用程序时，如果是控制台应用程序，则建议初始化一个QCoreApplication对象，Qt 5.11创建控制台项目时生成的main.cpp源文件中默认创建了一个QCoreApplication对象；如果是GUI图形用户界面程序，则会初始化一个QApplication对象。

    QList<int> list;					//创建一个QList<int>栈对象list
    list<<1<<2<<3<<4<<5;				//用操作运算符“<<”输入五个整数
    QListIterator<int> i(list);				//以该list为参数初始化一个QListIterator对象i。此时，迭代点处在第一个列表项“1”的前面（注意，并不是指向该列表项）。

    for(;i.hasNext();)	//调用QListIterator<T>::hasNext()函数检查当前迭代点之后是否有列表项。如果有，则调用QListIterator<T>::next()函数进行遍历。next()函数将会跳过下一个列表项（即迭代点将位于第一个列表项和第二个列表项之间），并返回它跳过的列表项的内容。

        qDebug()<<i.next();
    return a.exec();
}
//12345

上例是QListIterator<T>对列表进行向后遍历的函数，而对列表进行向前遍历的函数有如下几种。 QListIterator<T>::toBack()：将迭代点移动到最后一个列表项的后面。 QListIterator<T>::hasPrevious()：检查当前迭代点之前是否具有列表项。 QListIterator<T>::previous()：返回前一个列表项的内容并将迭代点移动到前一个列表项之前。 除此之外，QListIterator<T>提供的其他函数还有如下几种。 toFront()：移动迭代点到列表的前端（第一个列表项的前面）。

peekNext()：返回下一个列表项，但不移动迭代点。

peekPrevious()：返回前一个列表项，但不移动迭代点。

findNext()：从当前迭代点开始向后查找指定的列表项，如果找到，则返回true，此时迭代点位于匹配列表项的后面；如果没有找到，则返回false，此时迭代点位于列表的后端（最后一个列表项的后面）。

findPrevious()：与findNext()类似，不同的是，它的方向是向前的，查找操作完成后的迭代点在匹配项的前面或整个列表的前端。

（2）QListIterator<T>是只读迭代器，它不能完成列表项的插入和删除操作。读写迭代器QMutableListIterator<T>除提供基本的遍历操作（与QListIterator的操作相同）外，还提供了insert()插入操作函数、remove()删除操作函数和修改数据函数等。

#include <QCoreApplication>
#include <QDebug>
int main(int argc,char *argv[])
{
	QCoreApplication a(argc, argv);
	QList<int> list;				//创建一个空的列表list
	QMutableListIterator<int> i(list);			//创建上述列表的读写迭代器
	for(int j=0;j<10;++j)
		i.insert(j);//通过QMutableListIterator<T>::insert()插入操作，为该列表插入10个整数值。

	for(i.toFront();i.hasNext();)//将迭代器的迭代点移动到列表的前端，完成对列表的遍历和输出。

		qDebug()<<i.next();
	for(i.toBack();i.hasPrevious();)//移动迭代器的迭代点到列表的后端，对列表进行遍历。如果前一个列表项的值为偶数，则将该列表项删除；否则，将该列表项的值修改为原来的10倍。

	{
		if(i.previous()%2==0)
	       ?i.remove();
		else
	        i.setValue(i.peekNext()*10);// i.setValue(i.peekNext()*10)：函数QMutableListIterator<T>::setValue()修改遍历函数next()、previous()、findNext()和findPrevious()跳过的列表项的值，但不会移动迭代点的位置。对于findNext()和findPrevious()有些特殊：当findNext()（或findPrevious()）查找到列表项的时候，setValue()将会修改匹配的列表项；如果没有找到，则对setValue()的调用将不会进行任何修改。

	}
	for(i.toFront();i.hasNext();)			//重新遍历并输出列表
		    qDebug()<<i.next();
	return a.exec();
}

1.5．STL风格迭代器遍历容器

对于每个容器类，Qt都提供了两种类型的STL风格迭代器数据类型：一种提供只读访问；另一种提供读写访问。由于只读类型的迭代器的运行速度要比读写迭代器的运行速度快，所以应尽可能地使用只读类型的迭代器。

STL风格迭代器的两种分类见表2.3。 STL风格迭代器的API是建立在指针操作基础上的。例如，“++”操作运算符移动迭代器到下一个项（item），而“*”操作运算符返回迭代器指向的项。

#include <QCoreApplication>
#include <QDebug>
int main(int argc,char *argv[])
{
	QCoreApplication a(argc, argv);
	QList<int> list;				//初始化一个空的QList<int>列表
	for(int j=0;j<10;j++)
		list.insert(list.end(),j);		//使用QList<T>::insert()函数插入10个整数值。此函数有两个参数：第一个参数是QList<T>::iterator类型，表示在该列表项之前插入一个新的列表项（使用QList<T>::end()函数返回的迭代器，表示在列表的最后插入一个列表项）；第二个参数指定了需要插入的值。

	QList<int>::iterator i;
	//初始化一个QList<int>::iterator读写迭代器
	for(i=list.begin();i!=list.end();++i)		//在控制台输出列表的同时将列表的所有值增大10倍。这里用到两个函数：QList<T>::begin()函数返回指向第一个列表项的迭代器；QList<T>::end()函数返回一个容器最后列表项之后的虚拟列表项，为标记无效位置的迭代器，用于判断是否到达容器的底部。

	{
		   qDebug()<<(*i);
		   *i=(*i)*10;
	}
	//初始化一个QList<int>:: const_iterator读写迭代器
	QList<int>::const_iterator ci;
	//在控制台输出列表的所有值
	for(ci=list.constBegin();ci!=list.constEnd();++ci)
		    qDebug()<<*ci;
	return a.exec();
}

2、QMap类和QHash类

2.1QMap类和QHash类

QMap类和QHash类具有非常类似的功能，它们的差别仅在于：

? QHash具有比QMap更快的查找速度。

? QHash以任意的顺序存储数据项，而QMap总是按照键Key的顺序存储数据。

? QHash的键类型Key必须提供operator==()和一个全局的qHash(Key)函数，而QMap的键类型Key必须提供operator<()函数。 QMap和QHash的时间复杂度比较见表2.4。

2.2QMap

QMap<Key,T>提供了一个从类型为Key的键到类型为T的值的映射。 通常，QMap存储的数据形式是一个键对应一个值，并且按照键Key的顺序存储数据。为了能够支持一键多值的情况，QMap提供了QMap<Key,T>::insertMulti()和QMap<Key,T>::values()函数。存储一键多值的数据时，也可以使用QMultiMap<Key,T>容器，它继承自QMap。

2.3QHash

QHash<Key,T>具有与QMap几乎完全相同的API。QHash维护着一张哈希表（Hash Table），哈希表的大小与QHash的数据项的数目相适应。 QHash以任意的顺序组织它的数据。当存储数据的顺序无关紧要时，建议使用QHash作为存放数据的容器。QHash也可以存储一键多值形式的数据，它的子类QMultiHash<Key,T>实现了一键多值的语义。

2.4Java风格迭代器遍历容器

对于每一个容器类，Qt都提供了两种类型的Java风格迭代器数据类型：一种提供只读访问；另一种提供读写访问。Java风格迭代器的两种分类见表2.5。

2.5．STL风格迭代器遍历容器

对于每一个容器类，Qt都提供了两种类型的STL风格迭代器数据类型：一种提供只读访问；另一种提供读写访问。STL风格迭代器的两种分类见表2.6。

3、QVariant类

(a) QVariant v(709)：声明一个QVariant变量v，并初始化为一个整数。此时，QVariant变量v包含了一个整数变量。

(b) qDebug()<<v.toInt()：调用QVariant::toInt()函数将QVariant变量包含的内容转换为整数并输出。 (c) QVariant w("How are you! ")：声明一个QVariant变量w，并初始化为一个字符串。

(d) qDebug()<<w.toString()：调用QVariant::toString()函数将QVariant变量包含的内容转换为字符串并输出。

(e) QMap<QString,QVariant>map：声明一个QMap变量map，使用字符串作为键，QVariant变量作为值。

(f) qDebug()<<map["color"]<< map["color"].value<QColor>()：在QVariant变量中保存了一个QColor对象，并使用模板QVariant::value()还原为QColor，然后输出。

(g) if(slv.type()==QVariant::StringList)：QVariant::type()函数返回存储在QVariant变量中的值的数据类型。QVariant::StringList是Qt定义的一个QVariant::type枚举类型的变量。Qt的常用QVariant::type枚举类型变量见表2.7。

4、算法及正则表达式

4.1常用算法

其中， (a) double c=qAbs(a)：函数qAbs()返回double型数值a的绝对值，并赋值给c（c=19.3）。 (b) double max=qMax(b,c)：函数qMax()返回两个数值中的最大值（max=c=19.3）。

(c) int bn=qRound(b)：函数qRound()返回与一个浮点数最接近的整数值，即四舍五入返回一个整数值（bn=10，cn=19）。

(d) qSwap(bn,cn)：函数qSwap()交换两数的值。

4.2基本的正则表达式

正则表达式由表达式（expressions）、量词（quantifiers）和断言（assertions）组成。

（1）最简单的表达式是一个字符。字符集可以使用表达式如“[AEIOU]”，表示匹配所有的大写元音字母；使用“[^AEIOU]”，表示匹配所有非元音字母，即辅音字母；连续的字符集可以使用表达式如“[a-z]”，表示匹配所有的小写英文字母。

（2）量词说明表达式出现的次数，如“x[1,2]”表示“x”可以至少有一个，至多有两个。 在计算机语言中，标识符通常要求以字母或下画线（也称下画线）开头，后面可以是字母、数字和下画线。满足条件的标识符表示为：

" [A-Za-z_]+[A-Za-z_0-9]* "

其中，表达式中的“+”表示“[A-Za-z_]”至少出现一次，可以出现多次；“*”表示“[A-Za-z_0-9]”可以出现零次或多次。

正则表达式的量词见表2.8。

（3）“^”“$”“\b”都是正则表达式的断言，正则表达式的断言见表2.9。

例如，若要只有在using后面是namespace时才匹配using，则可以使用“using(?=E\s+ namespace)”（此处“?=E”后的“\s”表示匹配一个空白字符，下同）。 如果使用“using(?!E\s+namespace)”，则表示只有在using后面不是namespace时才匹配using。 如果使用“using\s+namespace”，则匹配为using namespace。