QString Class
Detailed Description 详细说明
QString存储一串16位QChars,其中每个QChar对应一个UTF-16代码单元。 (代码值大于65535的Unicode字符使用代理对,即两个连续的QChars存储。)
Unicode是一个国际标准,支持当今使用的大多数书写系统。它是US-ASCII(ANSI X3.4-1986)和Latin-1(ISO 8859-1)的超集,并且所有US-ASCII / Latin-1字符都位于相同的代码位置。
在后台,QString使用隐式共享(写时复制)来减少内存使用并避免不必要的数据复制。这也有助于减少存储16位字符而不是8位字符的固有开销。
除了QString,Qt还提供了QByteArray类来存储原始字节和传统的以8位’\0’终止的字符串。QString可以实现您的大多数目的。它在整个Qt API中使用,并且Unicode支持可确保您希望在某个时候扩展应用程序市场时轻松地翻译您的应用程序。 QByteArray适用的两种主要情况是:您需要存储原始二进制数据时,以及内存保留至关重要时(例如在嵌入式系统中)。
Initializing a String初始化字符串
初始化QString的一种方法是将const char *传递给其构造函数。例如,以下代码创建一个大小为5的QString,其中包含数据”Hello”:

QString使用fromUtf8()函数将const char数据转换为Unicode。
在所有使用const char
参数的QString函数中,const char被解释为以UTF-8编码的经典C风格’\0’终止的字符串。 const char参数为nullptr是合法的。
您还可以将字符串数据作为QChars数组提供:

QString会对QChar数据进行深层复制,因此您以后可以修改它而不会出现副作用。 (如果出于性能原因,您不想获取字符数据的深层副本,请改用QString::fromRawData().)
另一种方法是使用resize()设置字符串的大小并初始化每个字符的数据字符。 QString使用基于0的索引,就像C ++数组一样。要访问特定索引位置的字符,可以使用operator。在非常量字符串上,operator返回对可在赋值左侧使用的字符的引用。
例如:

对于只读访问,另一种语法是使用at()函数:

at()函数可以比operator更快,因为它永远不会导致深度复制的发生。或者,使用left(),right()或mid()函数一次提取多个字符。
QString可以嵌入’\0’字符(QChar::Null)。 size()函数始终返回整个字符串的大小,包括嵌入的’\0’字符。
调用resize()函数后,新分配的字符具有未定义的值。要将字符串中的所有字符设置为特定值,请使用fill()函数。
QString提供了数十种旨在简化字符串使用的重载。例如,如果您想将QString与字符串文字进行比较,则可以编写如下代码,它将按预期工作:

您还可以将字符串文字传递给以QString作为参数的函数,从而调用QString(const char *)构造函数。类似地,您可以使用qPrintable()宏将QString传递给采用const char *参数的函数,该宏将给定的QString作为const char *返回。这等效于调用 .toLocal8Bit().constData()
Manipulating String Data处理字符串数据
QString提供以下用于修改字符数据的基本功能:append(),prepend(),insert(),replace()和remove()。
例如:

如果您正在逐步构建QString并提前知道QString将包含多少个字符,则可以调用reserve(),要求QString预分配一定数量的内存。您也可以调用Capacity()来找出QString实际分配了多少内存。
replace()和remove()函数的前两个参数是开始擦除的位置以及应擦除的字符数。如果要用另一个替换所有出现的特定子字符串,请使用两个参数的replace()重载之一。
常见的要求是从字符串中删除空格字符(’\n’,’\t’,”等)。如果要从QString的两端删除空格,请使用trimmed()函数。如果要从两端删除空格并用字符串中的单个空格字符替换多个连续的空格,请使用simpleed()。
如果要查找QString中所有出现的特定字符或子字符串,请使用indexOf()或lastIndexOf()函数。前者从给定的索引位置开始向前搜索,后者向后搜索。两者都返回找到的字符或子字符串的索引位置;否则,它们返回-1。例如,下面是一个典型的循环,该循环查找特定子串的所有出现:

QString提供了许多用于将数字转换为字符串以及字符串转换为数字的功能。请参见arg()函数,setNum()函数,number()静态函数以及toInt(),toDouble()和类似函数。
要获取字符串的大写或小写版本,请使用toUpper()或toLower()。
字符串列表由QStringList类处理。您可以使用split()函数将字符串拆分为字符串列表,然后使用QStringList::join()函数使可选的分隔符将字符串列表合并为单个字符串。您可以使用QStringList::filter()函数从包含特定子字符串或与特定QRegExp匹配的字符串列表中获取字符串列表。
Querying String Data 查询字符串数据
如果要查看QString是否以特定的子字符串开头或结尾,请使用startsWith()或endsWith()。如果仅想检查QString是否包含特定字符或子字符串,请使用contains()函数。如果要确定字符串中某个特定字符或子字符串出现了多少次,请使用count()。
可以使用重载运算符(例如operator <(),operator =()等)来比较QString。请注意,比较仅基于字符的数字Unicode值。它的速度非常快,但不是人们期望的。 QString::localeAwareCompare()函数是对用户界面字符串进行排序的更好选择。
要获得指向实际字符数据的指针,请调用data()或constData()。这些函数返回一个指向QChar数据开头的指针。保证指针保持有效,直到在QString上调用非常量函数为止。
Converting Between 8-Bit Strings and Unicode Strings 在8位字符串和Unicode字符串之间转换
QString提供以下三个函数,以QByteArray的形式返回字符串的const char *版本:toUtf8(),toLatin1()和toLocal8Bit()。
toLatin1()返回Latin-1(ISO 8859-1)编码的8位字符串。
toUtf8()返回UTF-8编码的8位字符串。 UTF-8是US-ASCII(ANSI X3.4-1986)的超集,它通过多字节序列支持整个Unicode字符集。
toLocal8Bit()使用系统的本地编码返回8位字符串。
为了从这些编码中的一个进行转换,QString提供了fromLatin1(),fromUtf8()和fromLocal8Bit()。通过QTextCodec类支持其他编码。
如上所述,QString提供了许多函数和运算符,使它们易于与const char *字符串进行互操作。但是,此函数是一把双刃剑:如果所有字符串都是US-ASCII或Latin-1,它使QString更加方便使用,但是始终存在使用错误的方式从隐式转换为const char *的隐患。为了将这些风险降到最低,您可以通过定义以下两个预处理器符号来关闭这些隐式转换:
QT_NO_CAST_FROM_ASCII禁用从C字符串文字和指针到Unicode的自动转换。
QT_RESTRICTED_CAST_FROM_ASCII允许从C字符和字符数组自动转换,但是禁用从字符指针到Unicode的自动转换。
QT_NO_CAST_TO_ASCII禁用从QString到C字符串的自动转换。
为应用程序全局定义这些预处理器符号的一种方法是将以下条目添加到qmake项目文件中:

然后,您需要显式调用fromUtf8(),fromLatin1()或fromLocal8Bit()以从8位字符串构造QString,或使用轻量级QLatin1String类,例如:

同样,必须显式调用toLatin1(),toUtf8()或toLocal8Bit()才能将QString转换为8位字符串。 (通过QTextCodec类支持其他编码。)
Note for C Programmers C程序员注意事项
由于C ++的类型系统以及QString被隐式共享的事实,QString可以像ints或其他基本类型一样对待。例如:

结果变量是在堆栈上分配的普通变量。当调用return时,由于我们要按值返回,因此将调用copy构造函数,并返回字符串的副本。由于隐式共享,因此不会进行实际的复制。
Distinction Between Null and Empty Strings 空字符串与空字符串之间的区别
由于历史原因,QString区分空字符串和空字符串。空字符串是使用QString的默认构造函数或通过将(const char *)0传递给构造函数进行初始化的字符串。空字符串是任何大小为0的字符串。空字符串始终为空,但空字符串不一定为null:

除isNull()外的所有函数都将空字符串与空字符串相同。例如,toUtf8()。constData()返回指向空字符串的’\0’字符的有效指针(非nullptr)。我们建议您始终使用isEmpty()函数,并避免使用isNull()
Argument Formats 参数格式
在可以指定参数格式的成员函数中(例如,arg(),number()),参数格式可以是以下之一:

还使用参数格式指定精度。对于“e”,“E”和“f”格式,精度表示小数点后的位数。对于“g”和“G”格式,精度表示有效位数的最大数量(省略零位)。
More Efficient String Construction 更有效的弦线构造
在编译时已知许多字符串。但是琐碎的构造函数QString(“ Hello”)将复制字符串的内容,并将其内容视为Latin-1。为避免这种情况,可以使用QStringLiteral宏在编译时直接创建所需的数据。因此,根据文字构造QString不会在运行时引起任何开销。
效率稍差的方法是使用QLatin1String。此类包装C字符串文字,在编译时预先计算其长度,然后可以比常规C字符串文字更快地与QString比较和转换为QString。
使用QString’+’运算符,很容易从多个子字符串构造一个复杂的字符串。您将会经常编写如下代码:

这些字符串构造中的任何一个都没有错,但是存在一些隐藏的低效率。从Qt 4.6开始,您可以消除它们。
首先,多次使用“+”运算符通常意味着要分配多个内存。当串联n个子字符串(其中n>2)时,最多可以有n-1个对内存分配器的调用。
在4.6中,添加了内部模板类QStringBuilder以及一些辅助函数。此类被标记为内部类,因此未出现在文档中,因为您无意在代码中实例化该类。如下所述,它将自动使用。如果要查看该类,可以在src / corelib / tools / qstringbuilder.cpp中找到。
QStringBuilder使用表达式模板并重新实现’%’运算符,以便当您将’%’用于字符串连接而不是’+’时,多个子字符串连接将被推迟,直到最终结果将被分配给QString。至此,最终结果所需的内存量是已知的。然后,一次调用内存分配器以获取所需的空间,然后将子字符串一一复制到其中
通过内联和减少引用计数(通过QStringBuilder创建的QString通常具有ref计数为1,而QString ::append()需要额外测试),可以提高效率。
您可以通过两种方式访问此改进的字符串构造方法。直接的方法是在要使用QStringBuilder的任何地方,包括它,并在连接字符串时使用’%’运算符而不是’+’:

最方便但不完全与源代码兼容的全局方法是在.pro文件中进行以下定义:

并且’+’将在所有地方自动作为QStringBuilder’%’执行。
Maximum size and out-of-memory conditions最大size和内存不足情况
当前版本的QString的大小被限制2GB(2^31字节)以下。确切的值取决于体系结构,因为它取决于管理数据块所需的开销,但不超过32个字节。原始数据块还受当前版本中int类型的限制为2 GB减去1个字节。由于QString每个字符使用两个字节,因此在一个QString中转换为不足2^30个字符。
万一内存分配失败,QString将抛出std::bad_alloc异常。 Qt容器中的内存不足情况是Qt引发异常的唯一情况。
请注意,操作系统可能会对拥有大量已分配内存(尤其是大的连续块)的应用程序施加进一步的限制。这些考虑因素,此类行为的配置或任何缓解措施均不在Qt API的范围之内。
另请参见fromRawData(),QChar,QLatin1String,QByteArray和QStringRef。
Public Functions 公共函数
QString::QString(const QByteArray &ba)
构造一个用字节数组ba初始化的字符串。使用fromUtf8()将给定的字节数组转换为Unicode。在第一个0字符处停止复制,否则复制整个字节数组。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此构造函数。例如,如果要确保所有用户可见的字符串都通过QObject::tr(),这将很有用。
另请参见fromLatin1(),fromLocal8Bit(),fromUtf8()和QT_NO_CAST_FROM_ASCII
QString::QString(const char *str)
构造一个使用8位字符串str初始化的字符串。使用fromUtf8()函数将给定的const char指针转换为Unicode。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此构造函数。例如,如果要确保所有用户可见的字符串都通过QObject::tr(),这将很有用。
注意:定义QT_RESTRICTED_CAST_FROM_ASCII也会禁用此构造函数,但改为启用QString(const char(&ch)[N])构造函数。在这种情况下,未定义使用非文字输入,带有嵌入式NUL字符或非7位字符的输入。
另请参见fromLatin1(),fromLocal8Bit(),fromUtf8(),QT_NO_CAST_FROM_ASCII和QT_RESTRICTED_CAST_FROM_ASCII。
QString::QString(QString &&other)
Move构造一个QString实例,使其指向other对象指向的同一对象。
此函数在Qt 5.2中引入。
QString::QString(const QString &other)
构造other的副本。
由于QString是隐式共享的,因此此操作花费的时间是恒定的。这使得从函数快速返回QString。如果共享实例被修改,它将被复制(写时复制),这需要线性时间。
另请参阅operator =()。
QString::QString(QLatin1String str)
构造Latin-1字符串str的副本。
另请参见fromLatin1()。
QString::QString(int size, QChar ch)
构造一个给定大小的字符串,并将每个字符设置为ch。
另请参见fill()。
QString::QString(QChar ch)
构造一个大小为1的字符串,其中包含字符ch。
QString::QString(const QChar *unicode, int size = -1)
构造一个使用unicode的QChar数组并且第一个size字符初始化的字符串。
如果unicode为0,则构造一个空字符串。
如果size为负数,则假定unicode指向以\0’结尾的数组,并且其长度是动态确定的。终止的空字符不被视为字符串的一部分。
QString对字符串数据进行深层复制。 unicode数据按原样复制,并且保留字节顺序标记(如果存在)。
另请参见fromRawData()。
QString::QString()
构造一个空字符串。空字符串也为空。
另请参见isEmpty()。
QString &QString::operator=(const QByteArray &ba)
此函数重载operator =()。
将ba分配给此字符串。使用fromUtf8()函数将字节数组转换为Unicode。此函数在找到的第一个NUL字符或ba字节数组的末尾停止转换。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject::tr(),这将很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QString &QString::operator=(QString &&other)
将other对象移至此QString实例。
此函数在Qt 5.2中引入
QString &QString::operator=(const QString &other)
将此字符串分配为other,并返回对该字符串的引用。
QString::~QString()
销毁字符串。
QString &QString::append(const QString &str)
将字符串str追加到该字符串的末尾。例:

这与使用insert()函数相同:

append()函数通常非常快(恒定时间),因为QString在字符串数据的末尾预分配了额外的空间,因此它可以增长而不必每次都重新分配整个字符串。
另请参见operator + =(),prepend()和insert()。
QString &QString::append(QChar ch)
此函数重载append()。
将字符ch附加到此字符串。
QString &QString::append(const QChar *str, int len)
此函数重载append()。
将QChar数组str中的len个字符追加到此字符串。
此函数在Qt 5.0中引入。
QString &QString::append(const QStringRef &reference)
将给定的字符串引用附加到此字符串并返回结果。
此函数在Qt 4.4中引入。
QString &QString::append(QLatin1String str)
此函数重载append()。
将Latin-1字符串str附加到此字符串。
QString &QString::append(const char *str)
此函数重载append()。
将字符串str追加到此字符串。使用fromUtf8()函数将给定的const char指针转换为Unicode。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此函数。例如,如果要确保所有用户可见的字符串都通过QObject::tr(),这将很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QString &QString::append(const QByteArray &ba)
此函数重载append()。
将字节数组ba附加到此字符串。使用fromUtf8()函数将给定的字节数组转换为Unicode。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此函数。例如,如果要确保所有用户可见的字符串都通过QObject::tr(),这将很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QString QString::arg(const QString &a, int fieldWidth = 0, QChar fillChar = QLatin1Char(‘ ‘)) const
返回此字符串的副本,该副本的编号最低的地方标记被字符串a代替,即%1,%2,…,%99。
fieldWidth指定参数a占用的最小空间。如果a需要的空间小于fieldWidth,则使用字符fillChar将其填充到fieldWidth。正的fieldWidth生成右对齐的文本。负的fieldWidth会产生左对齐的文本。
本示例说明了如何在处理文件列表时创建状态字符串以报告进度:

首先,arg(i)替换%1。然后arg(total)替换%2。最后,arg(fileName)替换%3。
与应用程序asprintf()相比,使用arg()的一个优点是,如果将应用程序的字符串翻译成其他语言,则可以更改编号的位置标记的顺序,但是无论如何,每个arg()仍将替换编号最小的未替换位置标记它出现的位置。另外,如果位置标记%i在字符串中出现多次,则arg()会替换所有的位置。
如果没有剩余的未放置的位置标记,则输出警告消息,并且结果不确定。地标编号必须在1到99的范围内。
QString QString::arg(qlonglong a, int fieldWidth = 0, int base = 10, QChar fillChar =QLatin1Char(‘ ‘)) const
此函数重载arg()。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。
base参数指定将整数a转换为字符串时要使用的基数。基数必须在2到36之间,其中8给出八进制,10十进制和16十六进制数。
如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(qulonglong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。
base参数指定将整数a转换为字符串时要使用的基数。基数必须在2到36之间,其中8给出八进制,10十进制和16十六进制数。
如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(long a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。
参数以给定的底数表示,默认为10,且必须在2到36之间。
‘%’后面可以有’L’,在这种情况下,序列将替换为a的局部表示。转换使用默认语言环境。默认语言环境由应用程序启动时的系统语言环境设置确定。可以使用QLocale :: setDefault()进行更改。如果基数不是10,则忽略’L’标志。

如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(ulong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。
base参数指定将整数a转换为字符串时要使用的基数。基数必须在2到36之间,其中8给出八进制,10十进制和16十六进制数。
如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(int a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
a参数以基数base表示,默认情况下为10,并且必须在2到36之间。对于除10以外的基数,a被视为无符号整数。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。
‘%’后面可以有’L’,在这种情况下,序列将替换为a的局部表示。转换使用由QLocale :: setDefault()设置的默认语言环境。如果未指定默认语言环境,则使用“ C”语言环境。如果基数不是10,则忽略’L’标志。

如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(uint a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
base参数指定将整数a转换为字符串时要使用的基数。基数必须在2到36之间。
如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(short a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。
base参数指定将整数a转换为字符串时要使用的基数。基数必须在2到36之间,其中8给出八进制,10十进制和16十六进制数。
如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(ushort a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。
base参数指定将整数a转换为字符串时要使用的基数。基数必须在2到36之间,其中8给出八进制,10十进制和16十六进制数。
如果fillChar为’0’(数字0,ASCII 48),则使用语言环境的零。对于负数,减号前可能会出现零填充。
QString QString::arg(double a, int fieldWidth = 0, char format = ‘g’, int precision = -1, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
参数a根据指定的格式和精度进行格式化。有关详细信息,请参见参数格式。
fieldWidth指定a填充和填充字符fillChar的最小空间量。正值产生右对齐的文本;负值会产生左对齐的文本。

‘%’后面可以有’L’,在这种情况下,序列将替换为a的局部表示。转换使用由QLocale :: setDefault()设置的默认语言环境。如果未指定默认语言环境,则使用“ C”语言环境。
如果fillChar为’0’(数字0,ASCII 48),则此函数将使用语言环境的零进行填充。对于负数,零填充可能会出现在减号之前。
另请参见QLocale :: toString()。
QString QString::arg(char a, int fieldWidth = 0, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
参数a解释为Latin-1字符。
QString QString::arg(QChar a, int fieldWidth = 0, QChar fillChar = QLatin1Char(‘ ‘)) const
此函数重载arg()。
QString QString::arg(QStringView a, int fieldWidth = 0, QChar fillChar = QLatin1Char(‘ ‘)) const
这是一个重载函数。
返回此字符串的副本,该字符串的最低位标记由字符串a替换,即%1,%2,…,%99。
fieldWidth指定a占用的最小空间。如果a所需的空间少于fieldWidth,则使用字符fillChar将其填充到fieldWidth。正的fieldWidth生成右对齐的文本。负的fieldWidth会产生左对齐的文本。
本示例说明了如何在处理文件列表时创建状态字符串以报告进度:

首先,arg(i)替换%1。然后arg(total)替换%2。最后,arg(fileName)替换%3。
与应用程序asprintf()相比,使用arg()的一个优势是,如果将应用程序的字符串翻译成其他语言,则可以更改编号的位置标记的顺序,但是每个arg()仍将替换编号最小的未替换位置标记,无论出现在哪里。另外,如果位置标记%i在字符串中出现多次,则arg()会替换所有它们。
如果没有剩余的未替换的位置标记,则会显示一条警告消息,并且结果不确定。地标编号必须在1到99的范围内。
Qt 5.10中引入了此函数。
QString QString::arg(QLatin1String a, int fieldWidth = 0, QChar fillChar = QLatin1Char(‘ ‘)) const
这是一个重载函数。
返回此字符串的副本,该字符串的最低位标记由字符串a替换,即%1,%2,…,%99。
fieldWidth指定a占用的最小空间。如果a所需的空间少于fieldWidth,则使用字符fillChar将其填充到fieldWidth。正的fieldWidth生成右对齐的文本。负的fieldWidth会产生左对齐的文本。
与应用程序asprintf()相比,使用arg()的一个优势是,如果将应用程序的字符串翻译成其他语言,则可以更改编号的位置标记的顺序,但是每个arg()仍将替换编号最小的未替换位置标记,无论出现在哪里。另外,如果位置标记%i在字符串中出现多次,则arg()会替换所有它们。
如果没有剩余的未替换的位置标记,则会显示一条警告消息,并且结果不确定。地标编号必须在1到99的范围内。
此函数是在Qt 5.10中引入的。
QString QString::arg(const QString &a1, const QString &a2) const
此函数重载arg()。
这与str.arg(a1).arg(a2)相同,除了字符串a1和a2一次替换。如果a1包含例如%1:

当编号的地方标记没有用空格分隔时,会发生类似的问题:

让我们看一下替换:
首先,Hello替换%1,因此字符串变为“ Hello%3%2”。
然后,20替换%2,因此字符串变为“ Hello%320”。
由于最大的数字位置标记值为99,因此50将替换%32。
因此,字符串最终变为“ Hello500”。
在这种情况下,将产生预期的结果:

QString QString::arg(const QString &a1,const QString &a2, const QString &a3) const
此函数重载arg()。
这与调用str.arg(a1).arg(a2).arg(a3)相同,除了字符串a1,a2和a3一次替换。
QString QString::arg(const QString &a1,const QString &a2, const QString &a3, const QString &a4) const
此函数重载arg()。
这与调用str.arg(a1).arg(a2).arg(a3).arg(a4)相同,除了字符串a1,a2,a3和a4一次替换。
QString QString::arg(const QString &a1,const QString &a2,const QString &a3,const QString &a4, const QString &a5) const
此函数重载arg()。
这与调用str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5)相同,除了字符串a1,a2,a3,a4和a5被替换为一关。
QString QString::arg(const QString &a1,const QString &a2,const QString &a3,const QString &a4, const QString &a5, const QString &a6) const
此函数重载arg()。
这与调用str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6))相同,除了字符串a1,a2,a3,a4 ,a5和a6一次替换。
QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5, const QString &a6, const QString &a7) const
此函数重载arg()。
这与调用str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7)相同,除了字符串a1,a2一次替换a3,a4,a5,a6和a7。
QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5, const QString &a6, const QString &a7, const QString &a8) const
此函数重载arg()。
这与调用str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8)相同一次替换字符串a1,a2,a3,a4,a5,a6,a7和a8。
QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5, const QString &a6, const QString &a7, const QString &a8, const QString &a9)const
此函数重载arg()。
这与调用str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8).arg( a9),只是一次替换了字符串a1,a2,a3,a4,a5,a6,a7,a8和a9。
const QChar QString::at(int position) const
返回字符串中给定索引位置处的字符。
该位置必须是字符串中的有效索引位置(即0 <= position isNull()) {
qDebug() <unicode();
++data;
}
注意,仅当字符串未通过其他方式修改时,指针才保持有效。 对于只读访问,constData()更快,因为它永远不会引起深层复制。
另请参见constData()和operator []()。
const QChar *QString::data() const
这是一个过载功能。
注意:返回的字符串不能以’\ 0’结尾。 使用size()确定数组的长度。
另请参见fromRawData()。
QString :: iterator QString :: end()
返回一个STL样式的迭代器,该迭代器指向虚拟字符在字符串中最后一个字符之后
另请参见begin()和constEnd()。
QString::const_iterator QString::end() const
此函数重载end()。
bool QString::endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
如果字符串以s结尾,则返回true;否则,返回false。否则返回false。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
QString str = “Bananas”;
str.endsWith(“anas”); // returns true
str.endsWith(“pple”); // returns false
另请参见startsWith()。
bool QString::endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载endsWith()。
如果字符串以字符串引用s结尾,则返回true;否则,返回true。否则返回false。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
此功能在Qt 4.8中引入。
另请参见startsWith()。
bool QString::endsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载endsWith()。
如果字符串以字符串视图str结尾,则返回true;否则,返回true。否则返回false。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
Qt 5.10中引入了此功能。
另请参见startsWith()。
bool QString::endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载endsWith()。
bool QString::endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
如果字符串以c结尾,则返回true;否则返回false。否则返回false。
此函数重载endsWith()。
QString &QString::fill(QChar ch, int size = -1)
将字符串中的每个字符设置为字符ch。如果size与-1(默认值)不同,则将字符串预先调整为大小。
例如:
QString str = “Berlin”;
str.fill(‘z’);
// str == “zzzzzz”

str.fill('A', 2);
// str == "AA"

另请参见resize()。
[static]QString QString::fromCFString(CFStringRef string)
构造一个新的QString,其中包含CFString string的副本。
此功能仅在OS X和iOS上可用。
此功能在Qt 5.2中引入。
[static]QString QString::fromLatin1(const char *str, int size = -1)
返回一个QString,该字符串初始化为Latin-1字符串str的第一个大小字符。
如果size为-1(默认值),则将其视为strlen(str)。
另请参见toLatin1(),fromUtf8()和fromLocal8Bit()。
QString QString::fromLatin1(const QByteArray &str)
这是一个过载功能。
返回以Latin-1字符串str初始化的QString。
此功能在Qt 5.0中引入。
QString QString::fromLocal8Bit(const char *str, int size = -1)
返回以8位字符串str的第一个大小字符初始化的QString。
如果size为-1(默认值),则将其视为strlen(str)。
QTextCodec :: codecForLocale()用于执行转换。
另请参见toLocal8Bit(),fromLatin1()和fromUtf8()。
QString QString::fromLocal8Bit(const QByteArray &str)
这是一个过载功能。
返回使用8位字符串str初始化的QString。
此功能在Qt 5.0中引入。
QString QString::fromNSString(const NSString *string)
构造一个新的QString,其中包含字符串NSString的副本。
此功能仅在OS X和iOS上可用。
此功能在Qt 5.2中引入。
QString QString::fromRawData(const QChar *unicode, int size)
构造一个使用字符串unicode中的第一位Unicode字符的QString。 unicode中的数据不会被复制。只要存在QString(或其未修改的副本),调用者就必须能够保证不会删除或修改unicode。
任何尝试修改QString或它的副本的尝试都将导致它创建数据的深层副本,以确保未修改原始数据。
这是一个示例,该示例说明如何在内存中的原始数据上使用QRegularExpression而不需要将数据复制到QString中:
QRegularExpression pattern(“\u00A4”);
static const QChar unicode[] = {
0x005A, 0x007F, 0x00A4, 0x0060,
0x1009, 0x0020, 0x0020};
int size = sizeof(unicode) / sizeof(QChar);

QString str = QString::fromRawData(unicode, size);
if (str.contains(pattern) {
        // ...
}

警告:使用fromRawData()创建的字符串不是’\ 0’终止的,除非原始数据在位置大小处包含’\ 0’字符。这意味着unicode()将不会返回以’\ 0’结尾的字符串(尽管utf16()会返回,但以复制原始数据为代价)。
另请参见fromUtf16()和setRawData()。
QString QString::fromStdString(const std::string &str)
返回str字符串的副本。使用fromUtf8()函数将给定的字符串转换为Unicode。
另请参见fromLatin1(),fromLocal8Bit(),fromUtf8()和QByteArray :: fromStdString()。
QString QString::fromStdU16String(const std::u16string &str)
返回str字符串的副本。假定给定的字符串以UTF-16编码。
此功能在Qt 5.5中引入。
另请参见fromUtf16(),fromStdWString()和fromStdU32String()。
QString QString::fromStdU32String(const std::u32string &str)
返回str字符串的副本。假定给定的字符串以UCS-4编码。
此功能在Qt 5.5中引入。
另请参见fromUcs4(),fromStdWString()和fromStdU16String()。
QString QString::fromStdWString(const std::wstring &str)
返回str字符串的副本。如果wchar_t的大小为2个字节(例如在Windows上),则假定给定的字符串在utf16中进行编码;如果wchar_t的大小为4个字节(大多数Unix系统),则假定为ucs4。
另请参见fromUtf16(),fromLatin1(),fromLocal8Bit(),fromUtf8(),fromUcs4(),fromStdU16String()和fromStdU32String()。
QString QString::fromUcs4(const uint *unicode, int size = -1)
返回一个QString,该字符串初始化为Unicode字符串unicode(ISO-10646-UCS-4编码)的前几个字符。
如果size为-1(默认值),则unicode必须以\ 0’结尾。
此功能在Qt 4.2中引入。
另请参见toUcs4(),fromUtf16(),utf16(),setUtf16(),fromWCharArray()和fromStdU32String()。
QString QString::fromUcs4(const char32_t *str, int size = -1)
返回一个QString,该字符串初始化为Unicode字符串str(ISO-10646-UCS-4编码)的首个大小字符。
如果size为-1(默认值),则str必须以’0’结尾
此功能在Qt 4.2中引入。
另请参见toUcs4(),fromUtf16(),utf16(),setUtf16(),fromWCharArray()和fromStdU32String()。
QString QString::fromUcs4(const char32_t *str, int size = -1)
返回一个QString,该字符串初始化为Unicode字符串str(ISO-10646-UCS-4编码)的首个大小字符。
如果size为-1(默认值),则str必须以’0’结尾。
此功能在Qt 5.3中引入。
另请参见toUcs4(),fromUtf16(),utf16(),setUtf16(),fromWCharArray()和fromStdU32String()。
QString QString::fromUtf8(const char *str, int size = -1)
返回一个QString,该字符串初始化为UTF-8字符串str的第一个大小字节。
如果size为-1(默认值),则将其视为strlen(str)。
UTF-8是Unicode编解码器,可以表示Unicode字符串(如QString)中的所有字符。但是,使用UTF-8可能会产生无效序列,如果发现任何无效序列,它们将被一个或多个“替换字符”替换,或被抑制。这些包括非Unicode序列,非字符,超长序列或编码为UTF-8的替代代码点。
只要所有UTF-8字符都在输入数据中终止,此功能就可以用于增量处理输入数据。字符串末尾的任何未终止字符都将被替换或取消显示。为了进行状态解码,请使用QTextDecoder。
另请参见toUtf8(),fromLatin1()和fromLocal8Bit()。
QString QString::fromUtf8(const QByteArray &str)
这是一个过载功能。
返回使用UTF-8字符串str初始化的QString。
此功能在Qt 5.0中引入。
QString QString::fromUtf16(const ushort *unicode, int size = -1)
返回一个QString,该字符串初始化为Unicode字符串unicode(ISO-10646-UTF-16编码)的前几个字符
如果size为-1(默认值),则unicode必须以\ 0’结尾。
此功能检查字节顺序标记(BOM)。如果丢失,则假定主机字节顺序。
与其他Unicode转换相比,此功能较慢。尽可能使用QString(const QChar *,int)或QString(const QChar *)。 QString可以对Unicode数据进行深层复制。
ee也是utf16(),setUtf16()和fromStdU16String()。
QString QString::fromUtf16(const char16_t *str, int size = -1)
返回一个QString,该字符串初始化为Unicode字符串str(ISO-10646-UTF-16编码)的首个大小字符。
如果size为-1(默认值),则str必须以’0’结尾。
此功能检查字节顺序标记(BOM)。如果丢失,则假定主机字节顺序。
与其他Unicode转换相比,此功能较慢。尽可能使用QString(const QChar *,int)或QString(const QChar *)。
QString可以对Unicode数据进行深层复制。
他的功能在Qt 5.3中引入。
请参见utf16(),setUtf16()和fromStdU16String()。
QString QString::fromWCharArray(const wchar_t *string, int size = -1)
返回string的副本,其中字符串的编码取决于wchar的大小。如果wchar为4字节,则字符串解释为UCS-4;如果wchar为2字节,则string解释为UTF-16。
如果size为-1(默认值),则字符串必须以\ 0’结尾。
此功能在Qt 4.2中引入。
另请参见fromUtf16(),fromLatin1(),fromLocal8Bit(),fromUtf8(),fromUcs4()和fromStdWString()。
QChar QString::front() const
返回字符串中的第一个字符。与at(0)相同。
提供此功能是为了实现STL兼容性
警告:在空字符串上调用此函数会构成未定义的行为。
Qt 5.10中引入了此功能。
另请参见back(),at()和operator []()。
QCharRef QString::front()
返回对字符串中第一个字符的引用。与operator [](0)相同。
提供此功能是为了实现STL兼容性。
警告:在空字符串上调用此函数会构成未定义的行为。
Qt 5.10中引入了此功能。
另请参见back(),at()和operator []()。
int QString::indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
返回字符串str在此字符串中首次出现的索引位置,从索引位置from开始向前搜索。如果找不到str,则返回-1。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
例如:
QString x = “sticky question”;
QString y = “sti”;
x.indexOf(y); // returns 0
x.indexOf(y, 1); // returns 10
x.indexOf(y, 10); // returns 10
x.indexOf(y, 11); // returns -1
如果from为-1,则从最后一个字符开始搜索;否则,搜索从最后一个字符开始。如果为-2,则位于最后一个字符的第二个字符附近,依此类推。
此功能在Qt 4.5中引入。
另请参见lastIndexOf(),contains()和count()。
int QString::indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载indexOf()。
返回字符ch在字符串中首次出现的索引位置,从索引位置from开始向前搜索。如果找不到ch,则返回-1。
int QString::indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
返回字符串str在此字符串中首次出现的索引位置,从索引位置from开始向前搜索。如果找不到str,则返回-1。
If cs is Qt::CaseSensitive (default), the search is case sensitive; otherwise the search is case insensitive.
例如:
QString x = “sticky question”;
QString y = “sti”;
x.indexOf(y); // returns 0
x.indexOf(y, 1); // returns 10
x.indexOf(y, 10); // returns 10
x.indexOf(y, 11); // returns -1
如果from为-1,则从最后一个字符开始搜索;否则,搜索从最后一个字符开始。如果为-2,则位于最后一个字符的第二个字符附近,依此类推。
另请参见lastIndexOf(),contains()和count()。
int QString::indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载indexOf()。
返回字符串参考str在此字符串中首次出现的索引位置,从索引位置from开始向前搜索。如果找不到str,则返回-1。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
此功能在Qt 4.8中引入。
int QString::indexOf(QStringView str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载indexOf()。
返回字符串视图str在此字符串中首次出现的索引位置,从索引位置from开始向前搜索。如果找不到str,则返回-1。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
如果from为-1,则从最后一个字符开始搜索;否则,搜索从最后一个字符开始。如果为-2,则位于最后一个字符的第二个字符附近,依此类推。
Qt 5.14中引入了此功能。
另请参见QStringView :: indexOf(),lastIndexOf(),contains()和count()。
int QString::indexOf(const QRegExp &rx, int from = 0) const
此函数重载indexOf()。
返回字符串中正则表达式rx的第一个匹配项的索引位置,从索引位置from开始向前搜索。如果rx在任何地方都不匹配,则返回-1。
例如:
QString str = “the minimum”;
str.indexOf(QRegExp(“m[aeiou]”), 0); // returns 4
int QString::indexOf(QRegExp &rx, int from = 0) const
此函数重载indexOf()。
返回字符串中正则表达式rx的第一个匹配项的索引位置,从索引位置from开始向前搜索。如果rx在任何地方都不匹配,则返回-1。
如果存在匹配项,则rx正则表达式将包含匹配的捕获(请参见QRegExp :: matchedLength,QRegExp :: cap)。
例如:
QString str = “the minimum”;
str.indexOf(QRegExp(“m[aeiou]”), 0); // returns 4
此功能在Qt 4.5中引入。
int QString::indexOf(const QRegularExpression &re, int from = 0) const
此函数重载indexOf()。
返回正则表达式re在字符串中的第一个匹配项的索引位置,从索引位置from开始向前搜索。
如果re在任何地方都不匹配,则返回-1。
例如:
QString str = “the minimum”;
str.indexOf(QRegularExpression(“m[aeiou]”), 0); // returns 4
此功能在Qt 5.0中引入。
int QString::indexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const
这是一个过载功能。
返回正则表达式re在字符串中的第一个匹配项的索引位置,从索引位置from开始向前搜索。
如果re在任何地方都不匹配,则返回-1。
如果匹配成功并且rmatch不为nullptr,则还将匹配结果写入rmatch所指向的QRegularExpressionMatch对象。
例如:
QString str = “the minimum”;
QRegularExpressionMatch match;
str.indexOf(QRegularExpression(“m[aeiou]”), 0, &match); // returns 4
// match.captured() == mi
此功能在Qt 5.5中引入。
QString &QString::insert(int position,const QString &str)
将字符串str插入给定的索引位置,并返回对该字符串的引用。
例如:
QString str = “Meal”;
str.insert(1, QString(“ontr”));
// str == “Montreal”
如果给定位置大于size(),则首先使用resize()扩展数组。
另请参见append(),prepend(),replace()和remove()。
QString &QString::insert(int position, QChar ch)
此函数重载insert()。
将ch插入字符串中给定的索引位置。
QString &QString::insert(int position,const QChar *unicode, int size)
此函数重载insert()。
在字符串的给定索引位置插入QChar数组unicode的第一个大小字符。
QString &QString::insert(int position,const QStringRef &str)
此函数重载insert()。
将字符串引用str插入给定的索引位置,并返回对该字符串的引用。
如果给定位置大于size(),则首先使用resize()扩展数组。
此功能在Qt 5.5中引入。
QString &QString::insert(int position, QLatin1String str)
此函数重载insert()。
在给定的索引位置插入Latin-1字符串str
QString &QString::insert(int position,const char *str)
此函数重载insert()。
将C字符串str插入给定的索引位置position,并返回对该字符串的引用。
如果给定位置大于size(),则首先使用resize()扩展数组。
定义QT_NO_CAST_FROM_ASCII时,此功能不可用。
此功能在Qt 5.5中引入。
另请参见QT_NO_CAST_FROM_ASCII。
QString &QString::insert(int position,const QByteArray &str)
此函数重载insert()。
将字节数组str插入给定的索引位置position,并返回对此字符串的引用。
如果给定位置大于size(),则首先使用resize()扩展数组。
定义QT_NO_CAST_FROM_ASCII时,此功能不可用。
此功能在Qt 5.5中引入。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::isEmpty() const
如果字符串没有字符,则返回true;否则返回false。否则返回false。
例如:
QString().isEmpty(); // returns true
QString(“”).isEmpty(); // returns true
QString(“x”).isEmpty(); // returns false
QString(“abc”).isEmpty(); // returns false
另请参见size()。
bool QString::isLower() const
如果字符串为小写,则返回true,即与其toLower()折叠相同。
请注意,这并不意味着该字符串不包含大写字母(某些大写字母没有小写字母折叠; toLower()将其保留不变)。有关更多信息,请参阅Unicode标准第3.13节。
此功能在Qt 5.12中引入。
另请参见QChar :: toLower()和isUpper()。
bool QString::isNull() const
如果此字符串为null,则返回true;否则返回false。否则返回false。
例如:
QString().isNull(); // returns true
QString(“”).isNull(); // returns false
QString(“abc”).isNull(); // returns false
由于历史原因,Qt区分空字符串和空字符串。对于大多数应用程序,重要的是字符串是否包含任何数据,这可以使用isEmpty()函数确定。
另请参见isEmpty()。
bool QString::isRightToLeft() const
如果从右到左读取字符串,则返回true。
另请参见QStringRef :: isRightToLeft()。
bool QString::isUpper() const
如果字符串为大写,则返回true,即与其toUpper()折叠相同。
请注意,这并不能意味着该字符串不包含小写字母(某些小写字母没有大写一个折叠;它们被保持不变TOUPPER())。有关更多信息,请参阅Unicode标准第3.13节。
此功能在Qt 5.12中引入。
另请参见QChar :: toUpper()和isLower()。
int QString :: lastIndexOf(const QString&str,int from = -1,Qt :: CaseSensitivity cs = Qt :: CaseSensitive)const
返回字符串str在此字符串中最后一次出现的索引位置,从中从索引位置向后搜索。如果from为-1(默认值),则搜索从最后一个字符开始;如果from是-2,则在倒数第二个字符之后,依此类推。如果找不到str,则返回-1 。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。
例如
QString x = “crazy azimuths”;
QString y = “az”;
x.lastIndexOf(y); // returns 6
x.lastIndexOf(y, 6); // returns 6
x.lastIndexOf(y, 5); // returns 2
x.lastIndexOf(y, 1); // returns -1

另请参见indexOf(),contains()和count()。
int QString::lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载lastIndexOf()。
返回字符ch的最后一次出现的索引位置,从位置from向后搜索。
int QString::lastIndexOf(QLatin1String str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载lastIndexOf()。
返回字符串str在该字符串中最后一次出现的索引位置,从索引位置from开始向后搜索。如果from为-1(默认值),则搜索从最后一个字符开始;否则,开始搜索。如果from是-2,则在倒数第二个字符之后,依此类推。如果找不到str,则返回-1。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
例如:
QString x = “crazy azimuths”;
QString y = “az”;
x.lastIndexOf(y); // returns 6
x.lastIndexOf(y, 6); // returns 6
x.lastIndexOf(y, 5); // returns 2
x.lastIndexOf(y, 1); // returns -1
此功能在Qt 4.5中引入。
另请参见indexOf(),contains()和count()。
int QString::lastIndexOf(const QStringRef &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载lastIndexOf()。
返回此字符串中最后一次出现的字符串引用str的索引位置,从索引位置from开始向后搜索。如果from为-1(默认值),则搜索从最后一个字符开始;否则,开始搜索。如果from是-2,则在倒数第二个字符之后,依此类推。如果找不到str,则返回-1。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
此功能在Qt 4.8中引入。
另请参见indexOf(),contains()和count()。
int QString::lastIndexOf(QStringView str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载lastIndexOf()。
返回该字符串中最后一次出现的字符串视图str的索引位置,从索引位置from开始向后搜索。如果from为-1(默认值),则搜索从最后一个字符开始;否则,开始搜索。如果from是-2,则在倒数第二个字符之后,依此类推。如果找不到str,则返回-1。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
Qt 5.14中引入了此功能。
另请参见indexOf(),contains()和count()。
int QString::lastIndexOf(const QRegExp &rx, int from = -1) const
此函数重载lastIndexOf()。
返回字符串中正则表达式rx的最后一个匹配项的索引位置,从索引位置from开始向后搜索。如果rx在任何地方都不匹配,则返回-1。
例如:
QString str = “the minimum”;
str.lastIndexOf(QRegExp(“m[aeiou]”)); // returns 8
int QString::lastIndexOf(QRegExp &rx, int from = -1) const
此函数重载lastIndexOf()。
返回字符串中正则表达式rx的最后一个匹配项的索引位置,从索引位置from开始向后搜索。如果rx在任何地方都不匹配,则返回-1。
如果存在匹配项,则rx正则表达式将包含匹配的捕获(请参见QRegExp :: matchedLength,QRegExp :: cap)。
例如:
QString str = “the minimum”;
str.lastIndexOf(QRegExp(“m[aeiou]”)); // returns 8
此功能在Qt 4.5中引入。
int QString::lastIndexOf(QRegExp &rx, int from = -1) const
此函数重载lastIndexOf()。
返回字符串中正则表达式rx的最后一个匹配项的索引位置,从索引位置from开始向后搜索。如果rx在任何地方都不匹配,则返回-1。
如果存在匹配项,则rx正则表达式将包含匹配的捕获(请参见QRegExp :: matchedLength,QRegExp :: cap)。
例如:
QString str = “the minimum”;
str.lastIndexOf(QRegExp(“m[aeiou]”)); // returns 8
此功能在Qt 4.5中引入。
int QString::lastIndexOf(const QRegularExpression &re, int from = -1) const
此函数重载lastIndexOf()。
返回字符串中正则表达式re的最后一个匹配项的索引位置,该字符串从索引位置from开始。如果re在任何地方都不匹配,则返回-1。
例如:
QString str = “the minimum”;
str.lastIndexOf(QRegularExpression(“m[aeiou]”)); // returns 8
此功能在Qt 5.0中引入。
int QString::lastIndexOf(const QRegularExpression &re, int from, QRegularExpressionMatch rmatch) const
这是一个过载功能。
返回字符串中正则表达式re的最后一个匹配项的索引位置,该字符串从索引位置from开始。如果re在任何地方都不匹配,则返回-1。
如果匹配成功并且rmatch不为nullptr,则还将匹配结果写入rmatch所指向的QRegularExpressionMatch对象。
例如:
QString str = “the minimum”;
QRegularExpressionMatch match;
str.lastIndexOf(QRegularExpression(“m[aeiou]”), -1, &match); // returns 8
// match.captured() == mu
此功能在Qt 5.5中引入。
QString QString::left(int n) const
返回一个子字符串,其中包含该字符串的最左边的n个字符。
如果n大于或等于size()或小于零,则返回整个字符串。
QString x = “Pineapple”;
QString y = x.left(4); // y == “Pine”
另请参见right(),mid(),startsWith(),chopped(),chop()和truncate()。
QString QString::leftJustified(int width, QChar fill = QLatin1Char(‘ ‘), bool truncate = false) const
返回一个大小为width的字符串,其中包含用填充字符填充的字符串。
如果truncate为false并且字符串的size()大于width,则返回的字符串是该字符串的副本。
QString s = “apple”;
QString t = s.leftJustified(8, ‘.’); // t == “apple…”
如果truncate为true,并且字符串的size()大于width,则删除位置宽度之后的字符串副本中的所有字符,并返回该副本。
QString str = “Pineapple”;
str = str.leftJustified(5, ‘.’, true); // str == “Pinea”
另请参见rightJustified()。
QStringRef QString::leftRef(int n) const
返回对字符串最左边n个字符的子字符串引用。
如果n大于或等于size()或小于零,则返回对整个字符串的引用。
QString x = “Pineapple”;
QStringRef y = x.leftRef(4); // y == “Pine”
此功能在Qt 4.4中引入
另请参见left(),rightRef(),midRef()和startsWith()。
int QString::length() const
返回此字符串中的字符数。等效于size()。
另请参见resize()。
int QString::localeAwareCompare(const QString &s1, const QString &s2)
将s1与s2进行比较,如果s1小于,等于或大于s2,则返回小于,等于或大于零的整数。
比较以区域设置和平台相关的方式执行。使用此功能可将排序后的字符串列表呈现给用户。
在macOS和iOS上,此功能根据“国际首选项”面板中的“排序列表的顺序”设置进行比较。
另请参见compare()和QLocale。
int QString::localeAwareCompare(const QString &other) const
此函数重载localeAwareCompare()。
将此字符串与另一个字符串进行比较,如果该字符串小于,等于或大于另一个字符串,则返回小于,等于或大于零的整数。
比较以区域设置和平台相关的方式执行。使用此功能可将排序后的字符串列表呈现给用户。
与localeAwareCompare(
this,other)相同。
int QString::localeAwareCompare(const QStringRef &other) const
此函数重载localeAwareCompare()。
将此字符串与other字符串进行比较,如果该字符串小于,等于或大于other字符串,则返回小于,等于或大于零的整数。
比较以区域设置和平台相关的方式执行。使用此功能可将排序后的字符串列表呈现给用户。
与localeAwareCompare(* this,other)相同。
此功能在Qt 4.5中引入。
int QString::localeAwareCompare(const QString &s1, const QStringRef &s2)
此函数重载localeAwareCompare()。
将s1与s2进行比较,如果s1小于,等于或大于s2,则返回小于,等于或大于零的整数。
比较以区域设置和平台相关的方式执行。使用此功能可将排序后的字符串列表呈现给用户。
此功能在Qt 4.5中引入。
QString QString::mid(int position, int n = -1) const
返回一个字符串,该字符串从指定的位置索引position开始,包含此字符串的n个字符。
如果位置索引position超过字符串的长度,则返回一个空字符串。如果从给定位置position开始的字符串中少于n个字符可用,或者n为-1(默认值),则该函数返回从指定位置position开始可用的所有字符。
例如:
QString x = “Nine pineapples”;
QString y = x.mid(5, 4); / y == “pine”
QString z = x.mid(5); // z == “pineapples”
另请参见left(),right(),chopped(),chop()和truncate()。
QStringRef QString::midRef(int position, int n = -1) const
从指定位置position开始,返回对该字符串的n个字符的子字符串引用。
如果位置超过字符串的长度,则返回空引用。
如果字符串中的可用字符少于n个(从给定位置开始),或者n为-1(默认值),则该函数将从指定位置position开始返回所有字符。
例如:
QString x = “Nine pineapples”;
QStringRef y = x.midRef(5, 4); // y == “pine”
QStringRef z = x.midRef(5); // z == “pineapples”
此功能在Qt 4.4中引入。
另请参见mid(),leftRef()和rightRef()。
QString QString::normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version = QChar::Unicode_Unassigned) const
根据给定版本的Unicode标准,以给定Unicode规范化模式返回字符串。
QString QString::number(long n, int base = 10)
根据指定的基数返回与数字n等效的字符串。
默认情况下,底数是10,并且必须在2到36之间。对于10以外的底数,n被视为无符号整数。
格式始终使用QLocale :: C,即英语/美国。要获取数字的本地化字符串表示形式,请使用带有适当语言环境的QLocale :: toString()。
long a = 63;
QString s = QString::number(a, 16); // s == “3f”
QString t = QString::number(a, 16).toUpper(); // t == “3F”
另请参见setNum()。
QString QString::number(int n, int base = 10)
这是一个过载功能。
QString QString::number(uint n, int base = 10)
这是一个过载功能。
QString QString::number(ulong n, int base = 10)
这是一个过载功能。
QString QString::number(qlonglong n, int base = 10)
这是一个过载功能。
QString QString::number(qulonglong n, int base = 10)
这是一个过载功能。
QString QString::number(double n, char format = ‘g’, int precision = 6)
返回与数字n等效的字符串,根据指定的格式和精度格式化。有关详细信息,请参见参数格式。
与QLocale :: toString()不同,此函数不支持用户的语言环境设置。
另请参见setNum()和QLocale :: toString()。
QString &QString::prepend(const QString &str)
将字符串str放在此字符串的开头,并返回对该字符串的引用。
例如:
QString x = “ship”;
QString y = “air”;
x.prepend(y);
// x == “airship”
另请参见append()和insert()
QString &QString::prepend(QChar ch)
此函数重载prepend()。
在此字符串前添加字符ch。
QString &QString::prepend(const QChar str, int len)
此函数重载prepend()。
将QChar数组str中的len个字符添加到此字符串,并返回对该字符串的引用。
此功能在Qt 5.5中引入。
QString &QString::prepend(const QStringRef &str)
此函数重载prepend()。
将字符串引用str附加到该字符串的开头,并返回对该字符串的引用。
此功能在Qt 5.5中引入。
QString &QString::prepend(QLatin1String str)
此函数重载了prepend()。
将Latin-1字符串str附加到此字符串。
QString &QString::prepend(const char *str)
此函数重载了prepend()。
将字符串str附加到此字符串。使用fromUtf8()函数将const char指针转换为Unicode。
您可以在编译应用程序时通过定QT_NO_CAST_FROM_ASCII来禁用此功能。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QString &QString::prepend(const QByteArray &ba)
此函数重载了prepend()
将字节数组ba附加到此字符串。使用fromUtf8()函数将字节数组转换为Unicode。
您可以在编译应用程序时通过定QT_NO_CAST_FROM_ASCII来禁用此功能。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
void QString::push_back(const QString &other)
提供此函数是为了实现STL兼容性,将给定的other字符串附加到此字符串的末尾。它等效于append(other)。
另请参见append()。
void QString::push_back(QChar ch)
这是一个过载功能。
将给定的ch字符附加到此字符串的末尾。
void QString::push_front(const QString &other)
提供此功能是为了实现STL兼容性,将给定的other字符串放在此字符串的开头。它等效于prepend(other)。
另请参见prepend()。
void QString::push_front(QChar ch)
这是一个过载功能。
将给定的ch字符添加到此字符串的开头
QString::reverse_iterator QString::rbegin()
以相反的顺序返回一个STL样式的反向迭代器,该迭代器指向字符串中的第一个字符。
此功能在Qt 5.6中引入。
另请参见begin(),crbegin()和rend()。
QString::const_reverse_iterator QString::rbegin() const
这是一个过载功能。
他的功能在Qt 5.6中引入。
QString &QString::remove(int position, int n)
从给定位置索引position处开始,从字符串中删除n个字符,并返回对该字符串的引用。
如果指定的位置索引position在字符串中,但位置+ n超出字符串的末尾,则字符串将在指定位置position被截断。
QString s = “Montreal”;
s.remove(1, 4);
// s == “Meal”
另请参见insert()和replace()。
QString &QString::remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive)
删除此字符串中字符ch的所有出现,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
例如:
QString t = “Ali Baba”;
t.remove(QChar(‘a’), Qt::CaseInsensitive);
// t == “li Bb”
这与replace(ch , “”,cs)相同。
请参见replace()。
QString &QString::remove(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive)
这是一个过载功能。
删除此字符串中给定的str字符串的所有出现,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
这与replace(str, “”,cs)相同。
此功能在Qt 5.11中引入。
另请参见replace()。
QString &QString::remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive)
删除此字符串中给定的str字符串的所有出现,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
这与replace(str, “”,cs)相同。
另请参见replace()。
QString &QString::remove(const QRegExp &rx)
删除字符串中每次出现的正则表达式rx,并返回对该字符串的引用。例如:
QString r = “Telephone”;
r.remove(QRegExp(“[aeiou].”));
// r == “The”
另请参见indexOf(),lastIndexOf()和replace()。
QString &QString::remove(const QRegularExpression &re)
删除字符串中所有出现的正则表达式re,并返回对该字符串的引用。例如:
QString r = “Telephone”;
r.remove(QRegularExpression(“[aeiou].”));
// r == “The”
此功能在Qt 5.0中引入。
另请参见indexOf(),lastIndexOf()和replace()。
QString::reverse_iterator QString::rend()
以相反的顺序返回一个STL样式的反向迭代器,该迭代器指向字符串中最后一个字符之后的一个。
此功能在Qt 5.6中引入。
另请参见end(),crend()和rbegin()。
QString::const_reverse_iterator QString::rend() const
这是一个过载功能。
此功能在Qt 5.6中引入。
QString QString::repeated(int times) const
返回此字符串的副本,重复指定的次数。
如果times小于1,则返回一个空字符串。
例如:
QString str(“ab”);
str.repeated(4); // returns “abababab”
他的功能在Qt 4.5中引入。
QString &QString::replace(int position, int n, const QString &after)
将索引位置position开头的n个字符替换为之后的字符串,并返回对此字符串的引用。
注意:如果指定的位置索引position在字符串内,但位置+ n超出字符串范围,则将调整n到字符串末尾停止。
例如:
QString x = “Say yes!”;
QString y = “no”;
x.replace(4, 3, y);
// x == “Say no!”
另请参见insert()和remove()。
QString &QString::replace(int position, int n, QChar after)
此函数重载replace()。
用索引后的字符替换从索引位置position开始的n个字符,并返回对此字符串的引用。
QString &QString::replace(int position, int n, const QChar *unicode, int size)
此函数重载replace()。
用QChar数组unicode的第一个大写字符替换从索引位置position开始的n个字符,并返回对此字符串的引用。
QString &QString::replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
after(之后)的字符替换before(之前)出现的每个字符,并返回对此字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。
QString &QString::replace(const QChar *before, int blen,const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
将此字符串中出现的前一个前blen字符替换为后一个前alen字符,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
此功能在Qt 4.5中引入。
QString &QString::replace(QLatin1String before, QLatin1String after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
将出现的每个字符串替换为after(之后)的字符串,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。
注意:替换后不会重新扫描文本。
此功能在Qt 4.5中引入。
QString &QString::replace(QLatin1String before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
将出现的每个字符串替换为after(之后)的字符串,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。
注意:替换后不会重新扫描文本。
此功能在Qt 4.5中引入。
QString &QString::replace(const QString &before, QLatin1String after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
将出现的每个字符串替换为after(之后)的字符串,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。
注意:替换后不会重新扫描文本。
此功能在Qt 4.5中引入。
QString &QString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
将出现的每个字符串替换为after(之后)的字符串,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
例如:
QString str = “colour behaviour flavour neighbour”;
str.replace(QString(“ou”), QString(“o”));
// str == “color behavior flavor neighbor”
替换文本在插入后不会重新扫描。
例如:
QString equis = “xxxxxx”;
equis.replace(“xx”, “x”);
// equis == “xxx”
QString &QString::replace(QChar ch, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
将字符串中每次出现的字符ch替换为after,然后返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。
QString &QString::replace(QChar c, QLatin1String after, Qt::CaseSensitivity cs = Qt::CaseSensitive)
此函数重载replace()。
用after(后面)的字符串替换每次出现的字符c,并返回对该字符串的引用。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。
注意:替换后不会重新扫描文本。
此功能在Qt 4.5中引入。
QString &QString::replace(const QRegExp &rx, const QString &after)
此函数重载replace()。
用after替换字符串中每次出现的正则表达式rx。返回对该字符串的引用。例如:
QString s = “Banana”;
s.replace(QRegExp(“a[mn]”), “ox”);
// s == “Boxoxa”
For regular expressions containing capturing parentheses, occurrences of \1, \2, …, in after are replaced with rx.cap(1), cap(2), …
QString t = “A bon mot.”;
t.replace(QRegExp(“([^<]
)“), “\emph{\1}”);
// t == “A \emph{bon mot}.”
另请参见indexOf(),lastIndexOf(),remove()和QRegExp :: cap()。
QString &QString::replace(const QRegularExpression &re, const QString &after)
此函数重载replace()。
用after替换字符串中每一次出现的正则表达式re。返回对该字符串的引用。例如:
QString s = “Banana”;
s.replace(QRegularExpression(“a[mn]”), “ox”);
// s == “Boxoxa”
对于包含捕获组的正则表达式,之后出现的\ 1,\ 2,…,被对应的捕获组捕获的字符串替换。
QString t = “A bon mot.”;
t.replace(QRegularExpression(“([^<]*)“), “\emph{\1}”);
// t == “A \emph{bon mot}.”
此功能在Qt 5.0中引入。
另请参见indexOf(),lastIndexOf(),remove(),QRegularExpression和QRegularExpressionMatch。
void QString::reserve(int size)
尝试为至少大小字符分配内存。如果事先知道字符串的大小,则可以调用此函数,并且如果经常调整字符串的大小,则可能会获得更好的性能。如果size被低估,那么最糟糕的情况就是QString会变慢。
此函数的唯一目的是提供一种微调QString的内存使用情况的方法。通常,您几乎不需要调用此函数。如果要更改字符串的大小,请调用resize()。
对于需要建立长字符串并希望避免重复分配的代码,此功能很有用。在此示例中,我们希望添加到字符串中直到某些条件成立为止,并且我们相当确定其大小足够大,值得进行对reserve()的调用:
QString result;
int maxSize;
bool condition;
QChar nextChar;

result.reserve(maxSize);

while (condition)
result.append(nextChar);

result.squeeze();

另请参见squeeze()和Capacity()。
void QString::resize(int size)
将字符串的大小设置为大小字符。
如果size大于当前大小,则字符串将被扩展以使其长度变长,并在末尾添加额外的字符。新字符未初始化。
如果大小小于当前大小,将从末尾删除字符。
例如:
QString s = “Hello world”;
s.resize(5);
// s == “Hello”

s.resize(8);
// s == "Hello???" (where ? stands for any character)

如果要在字符串后附加一定数量的相同字符,请使用resize(int,QChar)重载。
如果要扩展字符串以使其达到特定宽度并用特定字符填充新位置,请使用leftJustified()函数:
如果size为负,则等于传递零。
QString r = “Hello”;
r = r.leftJustified(10, ‘ ‘);
// r == “Hello ”
另请参见truncate()和reserve()。
void QString::resize(int size, QChar fillChar)
这是一个过载功能。
与resize(int)不同,此重载将新字符初始化为fillChar:
QString t = “Hello”;
r.resize(t.size() + 10, ‘X’);
// t == “HelloXXXXXXXXXX”
此功能在Qt 5.7中引入。
QString QString::right(int n) const
返回一个子字符串,其中包含该字符串的最右边的n个字符。
如果n大于或等于size()或小于零,则返回整个字符串。
QString x = “Pineapple”;
QString y = x.right(5); // y == “apple”
另请参见left(),mid(),endsWith(),chopped(),chop()和truncate()。
QString QString::rightJustified(int width, QChar fill = QLatin1Char(‘ ‘), bool truncate = false) const
返回一个size()宽度的字符串,其中包含填充字符,后跟该字符串。例如:
QString s = “apple”;
QString t = s.rightJustified(8, ‘.’); // t == “…apple”
如果truncate为false并且字符串的size()大于width,则返回的字符串是该字符串的副本。
如果truncate为true,并且字符串的size()大于width,则结果字符串在位置width处被截断。
QString str = “Pineapple”;
str = str.rightJustified(5, ‘.’, true); // str == “Pinea”
另请参见leftJustified()。
QStringRef QString::rightRef(int n) const
返回对字符串的n个最右字符的子字符串引用。
如果n大于或等于size()或小于零,则返回对整个字符串的引用。
QString x = “Pineapple”;
QStringRef y = x.rightRef(5); // y == “apple”
功能在Qt 4.4中引入。
另请参见right(),leftRef(),midRef()和endsWith()。
QString QString::section(QChar sep, int start, int end = …, QString::SectionFlags flags =SectionDefault) const
此函数返回字符串的一部分。
该字符串被视为由字符sep分隔的一系列字段。返回的字符串包含从位置开始到位置结束(包括首尾)的字段。如果未指定end,则包括从位置start到字符串结尾的所有字段。字段从左开始编号为0、1、2等,从右到左依次编号为-1,-2等。
flags参数可用于影响函数行为的某些方面,例如是否区分大小写,是否跳过空白字段以及如何处理前导和尾随分隔符;参见SectionFlags。
QString str;
QString csv = “forename,middlename,surname,phone”;
QString path = “/usr/local/bin/myapp”; // First field is empty
QString::SectionFlag flag = QString::SectionSkipEmpty;

str = csv.section(',', 2, 2);   // str == "surname"
str = path.section('/', 3, 4);  // str == "bin/myapp"
str = path.section('/', 3, 3, flag); // str == "myapp"

如果start或end为负,则从字符串的右边开始计数字段,最右边的字段为-1,最右边的字段为-2,依此类推。
str = csv.section(‘,’, -3, -2); // str == “middlename,surname”
str = path.section(‘/’, -1); // str == “myapp”
另请参见split()。
QString QString::section(const QString &sep, int start, int end = -1, QString::SectionFlags flags = SectionDefault) const
此函数重载section()。
QString str;
QString data = “forenamemiddlenamesurname**phone”;

str = data.section("**", 2, 2); // str == "surname"
str = data.section("**", -3, -2); // str == "middlename**surname"

另请参见split()。
QString QString::section(const QRegExp &reg, int start, int end = -1, QString::SectionFlags flags = SectionDefault) const
此函数重载section()。
该字符串被视为由正则表达式reg分隔的一系列字段。
QString line = “forename\tmiddlename surname \t \t phone”;
QRegExp sep(“\s+”);
str = line.section(sep, 2, 2); // str == “surname”
str = line.section(sep, -3, -2); // str == “middlename surname”
告:使用此QRegExp版本比重载的字符串和字符版本要昂贵得多。
另请参见split()和simplified()。
QString QString::section(const QRegularExpression &re, int start, int end=-1, QString::SectionFlags flags = SectionDefault) const
此函数重载section()。
该字符串被视为由正则表达式re分隔的一系列字段。
QString line = “forename\tmiddlename surname \t \t phone”;
QRegularExpression sep(“\s+”);
str = line.section(sep, 2, 2); // str == “surname”
str = line.section(sep, -3, -2); // str == “middlename surname”
警告:使用此QRegularExpression版本比重载的字符串和字符版本要昂贵得多。
此功能在Qt 5.0中引入。
另请参见split()和simplified()。
QString &QString::setNum(int n, int base = 10)
将字符串设置为指定基数中n的打印值,并返回对该字符串的引用。
默认情况下,底数是10,并且必须在2到36之间。对于10以外的底数,n被视为无符号整数。
QString str;
str.setNum(1234); // str == “1234”
格式始终使用QLocale :: C,即英语/美国。要获取数字的本地化字符串表示形式,请使用带有适当语言环境的QLocale :: toString()。
另请参见number()。
QString &QString::setNum(short n, int base = 10)
这是一个过载功能。
QString &QString::setNum(ushort n, int base = 10)
这是一个过载功能。
QString &QString::setNum(uint n, int base = 10)
这是一个过载功能。
QString &QString::setNum(long n, int base = 10)
这是一个过载功能。
QString &QString::setNum(ulong n, int base = 10)
这是一个过载功能。
QString &QString::setNum(qlonglong n, int base = 10)
这是一个过载功能。
QString &QString::setNum(qulonglong n, int base = 10)
这是一个过载功能。
QString &QString::setNum(float n, char format = ‘g’, int precision = 6)
这是一个过载功能。
将字符串设置为打印值n,并根据给定的格式和精度对其进行格式化,然后返回对该字符串的引用。
格式始终使用QLocale :: C,即英语/美国。要获取数字的本地化字符串表示形式,请使用带有适当语言环境的QLocale :: toString()。
另请参见number()。
QString &QString::setNum(double n, char format = ‘g’, int precision = 6)
这是一个过载功能。
将字符串设置为打印值n,并根据给定的格式和精度对其进行格式化,然后返回对该字符串的引用。
格式可以是“ e”,“ E”,“ f”,“ g”或“ G”(有关格式的说明,请参见参数格式)。
格式始终使用QLocale :: C,即英语/美国。要获取数字的本地化字符串表示形式,请使用带有适当语言环境的QLocale :: toString()。
另请参见number()。
QString &QString::setRawData(const QChar *unicode, int size)
重置QString以使用数组unicode中的第一位Unicode字符。 unicode中的数据不会被复制。只要存在QString(或其未修改的副本),调用者就必须能够保证不会删除或修改unicode。
可以使用此函数代替fromRawData()来重用现有的QString对象,以节省内存的重新分配。
此功能在Qt 4.7中引入。

另请参见fromRawData()。
QString &QString::setUnicode(const QChar *unicode, int size)
调整字符串size以调整字符大小,然后将unicode复制到字符串中。
如果unicode为0,则不会复制任何内容,但仍将字符串调整为大小。
另请参见unicode()和setUtf16()。
QString &QString::setUtf16(const ushort *unicode, int size)
调整字符串size以调整字符大小,然后将unicode复制到字符串中。
如果unicode为0,则不会复制任何内容,但仍将字符串调整为大小。
请注意,与fromUtf16()不同,此函数不考虑BOM表,并且可能不考虑字节顺序。
另请参见utf16()和setUnicode()。
void QString::shrink_to_fit()
提供此功能是为了实现STL兼容性。它等效于squeeze()。
他的功能在Qt 5.10中引入。
另请参见squeeze()。
QString QString::simplified() const
返回一个字符串,该字符串从开头和结尾删除了空格,并且内部空格的每个序列都被一个空格替换。
空格表示QChar :: isSpace()返回true的任何字符。这包括ASCII字符“ \ t”,“ \ n”,“ \ v”,“ \ f”,“ \ r”和“”。
例如:
QString str = ” lots\t of\nwhitespace\r\n “;
str = str.simplified();
// str == “lots of whitespace”;
另请参见trimmed()。
int QString::size() const
返回此字符串中的字符数。
字符串中的最后一个字符在位置size()-1。
例如:
QString str = “World”;
int n = str.size(); // n == 5
str.data()[0]; // returns ‘W’
str.data()[4]; // returns ‘d’
另请参见isEmpty()和resize()。
QStringList QString::split(const QString &sep, QString::SplitBehavior behavior =KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
在sep出现的任何位置将字符串拆分为子字符串,并返回这些字符串的列表。如果sep与字符串中的任何地方都不匹配,则split()返回包含此字符串的单元素列表。
cs指定sep应该区分大小写还是不区分大小写。
如果行为为QString :: SkipEmptyParts,则空条目不会出现在结果中。默认情况下,保留空条目。
例如:
QString str = “a,,b,c”;

QStringList list1 = str.split(',');
// list1: [ "a", "", "b", "c" ]

QStringList list2 = str.split(',', QString::SkipEmptyParts);
// list2: [ "a", "b", "c" ]

如果sep为空,则split()返回一个空字符串,然后是该字符串的每个字符,然后是另一个空字符串:
QString str = “abc”;
auto parts = str.split(“”);
// parts: {“”, “a”, “b”, “c”, “”}
要了解此行为,请记住空字符串在任何地方都匹配,因此上述内容在质量上与以下内容相同:
QString str = “/a/b/c/”;
auto parts = str.split(‘/’);
// parts: {“”, “a”, “b”, “c”, “”}
另请参见QStringList :: join()和section()。
QStringList QString::split(QChar sep, QString::SplitBehavior behavior =KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
这是一个过载功能。
QStringList QString::split(const QRegExp &rx, QString::SplitBehavior behavior = KeepEmptyParts) const
这是一个过载功能。
在正则表达式rx匹配的位置将字符串拆分为子字符串,并返回这些字符串的列表。如果rx与字符串中的任何地方都不匹配,则split()返回包含此字符串的单元素列表。
这是一个示例,其中我们使用一个或多个空格字符作为分隔符来提取句子中的单词:
QString str;
QStringList list;

str = "Some  text\n\twith  strange whitespace.";
list = str.split(QRegExp("\\s+"));
// list: [ "Some", "text", "with", "strange", "whitespace." ]

这是一个类似的示例,但是这次我们使用任何非单词字符序列作为分隔符:
str = “This time, a normal English sentence.”;
list = str.split(QRegExp(“\W+”), QString::SkipEmptyParts);
// list: [ “This”, “time”, “a”, “normal”, “English”, “sentence” ]
这是第三个示例,其中我们使用零长度断言\ b(单词边界)将字符串分成非单词和单词标记的交替序列:
str = “Now: this sentence fragment.”;
list = str.split(QRegExp(“\b”));
// list: [ “”, “Now”, “: “, “this”, ” “, “sentence”, ” “, “fragment”, “.” ]
另请参见QStringList :: join()和section()。
QStringList QString::split(const QRegularExpression &re, QString::SplitBehavior behavior = KeepEmptyParts) const
这是一个过载功能。
只要正则表达式匹配,就将字符串拆分为子字符串,并返回这些字符串的列表。如果re在字符串中的任何地方都不匹配,则split()返回包含此字符串的单元素列表。
这是一个示例,其中我们使用一个或多个空格字符作为分隔符来提取句子中的单词:
QString str;
QStringList list;

str = "Some  text\n\twith  strange whitespace.";
list = str.split(QRegularExpression("\\s+"));
// list: [ "Some", "text", "with", "strange", "whitespace." ]

这是一个类似的示例,但是这次我们使用任何非单词字符序列作为分隔符:
str = “This time, a normal English sentence.”;
list = str.split(QRegularExpression(“\W+”), QString::SkipEmptyParts);
// list: [ “This”, “time”, “a”, “normal”, “English”, “sentence” ]
这是第三个示例,其中我们使用零长度断言\ b(单词边界)将字符串分成非单词和单词标记的交替序列:
str = “Now: this sentence fragment.”;
list = str.split(QRegularExpression(“\b”));
// list: [ “”, “Now”, “: “, “this”, ” “, “sentence”, ” “, “fragment”, “.” ]
此功能在Qt 5.0中引入。
另请参见QStringList :: join()和section()。
QVectorQString::splitRef(const QString &sep, QString::SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
在Sep出现的任何地方将字符串拆分为子字符串引用,并返回这些字符串的列表。
参见QString :: split()了解sep,行为和CS如何相互作用以形成结果。
注意:只要此字符串有效,所有引用均有效。销毁该字符串将导致所有引用悬空指针。
此功能在Qt 5.4中引入。
另请参见QStringRef和split()。
QVectorQString::splitRef(QChar sep, QString::SplitBehavior behavior =KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
这是一个过载功能。
此功能在Qt 5.4中引入。
QVectorQString::splitRef(const QRegExp &rx, QString::SplitBehavior behavior = KeepEmptyParts) const
这是一个过载功能。
在正则表达式rx匹配的任何位置将字符串拆分为子字符串引用,并返回这些字符串的列表。如果rx与字符串中的任何地方都不匹配,则splitRef()返回包含此字符串引用的单元素向量。
注意:只要此字符串有效,所有引用均有效。销毁该字符串将导致所有引用悬空指针。
此功能在Qt 5.4中引入。
另请参见QStringRef和split()。
QVectorQString::splitRef(const QRegularExpression &re, QString::SplitBehavior behavior = KeepEmptyParts) const
这是一个过载功能。
在正则表达式重新匹配的位置将字符串拆分为子字符串引用,并返回这些字符串的列表。如果re在字符串中的任何地方都不匹配,则splitRef()返回包含此字符串引用的单元素向量。
注意:只要此字符串有效,所有引用均有效。销毁该字符串将导致所有引用悬空指针。
此功能在Qt 5.4中引入。
另请参见split()和QStringRef。
void QString::squeeze()
释放存储字符数据不需要的任何内存。
此函数的唯一目的是提供一种微调QString的内存使用情况的方法。通常,您几乎不需要调用此函数。
另请参见reserve()和Capacity()。
bool QString::startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
如果字符串以s开头,则返回true;否则返回false。否则返回false。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
QString str = “Bananas”;
str.startsWith(“Ban”); // returns true
str.startsWith(“Car”); // returns false
另请参见endsWith()。
bool QString::startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
这是一个过载功能。
如果字符串以字符串引用s开头,则返回true;否则返回true。否则返回false。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
此功能在Qt 4.8中引入。
另请参见endsWith()。
bool QString::startsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
这是一个过载功能。
如果字符串以string-view str开头,则返回true;否则,返回true。否则返回false。
如果cs是Qt :: CaseSensitive(默认),则搜索区分大小写;否则,搜索不区分大小写。否则,搜索不区分大小写。
此功能在Qt 5.10中引入。
另请参见endsWith()。
bool QString::startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载startsWith()。
bool QString::startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
此函数重载startsWith()。
如果字符串以c开头,则返回true;否则返回false。否则返回false。
void QString::swap(QString &other)
用此字符串交换其他字符串。此操作非常快,并且永远不会失败。
此功能在Qt 4.8中引入。
CFStringRef QString::toCFString() const
从QString创建CFString。调用者拥有CFString并负责释放它。
注意:此功能仅在OS X和iOS上可用。
此功能在Qt 5.2中引入。
QString QString::toCaseFolded() const
返回与字符串等效的大小写折叠。对于大多数Unicode字符,这与toLower()相同。
double QString::toDouble(bool ok = nullptr) const
返回转换为双精度值的字符串。
如果转换溢出,则返回无穷大;如果转换由于其他原因而失败(例如下溢),则返回无穷大。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
QString str = “1234.56”;
double val = str.toDouble(); // val == 1234.56
警告:QString内容只能包含有效的数字字符,包括加/减号,科学计数法中使用的字符e和小数点。包含单位或其他字符会导致转换错误。
bool ok;
double d;

d = QString( "1234.56e-02" ).toDouble(&amp;ok); // ok == true, d == 12.3456

d = QString( "1234.56e-02 Volt" ).toDouble(&amp;ok); // ok == false, d == 0

字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toDouble()
d = QString( “1234,56” ).toDouble(&ok); // ok == false
d = QString( “1234.56” ).toDouble(&ok); // ok == true, d == 1234.56
由于历史原因,此功能无法处理数千个组分隔符。如果需要转换此类数字,请使用QLocale :: toDouble()。
d = QString( “1,234,567.89” ).toDouble(&ok); // ok == false
d = QString( “1234567.89” ).toDouble(&ok); // ok == true
此函数忽略前导和尾随空格。
另请参见number(),QLocale :: setDefault(),QLocale :: toDouble()和trimmed()。
float QString::toFloat(bool ok = nullptr) const
返回转换为浮点值的字符串。
如果转换溢出,则返回无穷大;如果转换由于其他原因而失败(例如下溢),则返回无穷大。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
警告:QString内容只能包含有效的数字字符,包括加/减号,科学计数法中使用的字符e和小数点。包含单位或其他字符会导致转换错误。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toFloat()
由于历史原因,此功能无法处理数千个组分隔符。如果需要转换此类数字,请使用QLocale :: toFloat()。
例如:
QString str1 = “1234.56”;
str1.toFloat(); // returns 1234.56

bool ok;
QString str2 = "R2D2";
str2.toFloat(&amp;ok);          // returns 0.0, sets ok to false

QString str3 = "1234.56 Volt";
str3.toFloat(&amp;ok);          // returns 0.0, sets ok to false

此函数忽略前导和尾随空格。
另请参见number(),toDouble(),toInt(),QLocale :: toFloat()和trimmed()。
QString QString::toHtmlEscaped() const
将纯文本字符串转换为HTML字符串,其中HTML元字符,&和“被HTML实体替换。
例如:
QString plain = “#include ”
QString html = plain.toHtmlEscaped();
// html == “#include <QtCore>”
此功能在Qt 5.0中引入。
int QString::toInt(bool ok = nullptr, int base = 10) const
返回使用base base转换为int的字符串,默认情况下为10,且必须介于2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toInt()。
例如:
QString str = “FF”;
bool ok;
int hex = str.toInt(&ok, 16); // hex == 255, ok == true
int dec = str.toInt(&ok, 10); // dec == 0, ok == false
此函数忽略前导和尾随空格。
另请参见number(),toUInt(),toDouble()和QLocale :: toInt()。
QByteArray QString::toLatin1() const
以QByteArray形式返回字符串的Latin-1表示形式。
如果字符串包含非Latin1字符,则返回的字节数组是不确定的。这些字符可能会被禁止显示或被问号代替。
另请参见fromLatin1(),toUtf8(),toLocal8Bit()和QTextCodec。
QByteArray QString::toLocal8Bit() const
以QByteArray形式返回字符串的本地8位表示形式。如果字符串包含本地8位编码不支持的字符,则返回的字节数组是不确定的。
QTextCodec :: codecForLocale()用于执行从Unicode的转换。如果无法确定语言环境编码,则此函数与toLatin1()相同。
如果此字符串包含无法在语言环境中编码的任何字符,则返回的字节数组未定义。这些字符可能被抑制或被其他字符替换。
另请参见fromLocal8Bit(),toLatin1(),toUtf8()和QTextCodec。
long QString::toLong(bool ok =nullptr, int base = 10) const
返回使用基数基数转换为long的字符串,默认情况下为10,且必须在2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toLongLong()。
例如:
QString str = “FF”;
bool ok;

long hex = str.toLong(&amp;ok, 16);     // hex == 255, ok == true
long dec = str.toLong(&amp;ok, 10);     // dec == 0, ok == false

此函数忽略前导和尾随空格。
另请参见number(),toULong(),toInt()和QLocale :: toInt()。
qlonglong QString::toLongLong(bool ok = nullptr, int base = 10) const
返回使用base base转换为long long的字符串,默认情况下为10,且必须介于2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toLongLong()
例如:
QString str = “FF”;
bool ok;

qint64 hex = str.toLongLong(&amp;ok, 16);      // hex == 255, ok == true
qint64 dec = str.toLongLong(&amp;ok, 10);      // dec == 0, ok == false

此函数忽略前导和尾随空格。
另请参见number(),toULongLong(),toInt()和QLocale :: toLongLong()。
QString QString::toLower() const
返回字符串的小写副本。
QString str = “The Qt PROJECT”;
str = str.toLower(); // str == “the qt project”
大小写转换将始终在“ C”区域设置中进行。对于与语言环境相关的大小写折叠,请使用QLocale :: toLower()
另请参见toUpper()和QLocale :: toLower()。
NSString QString::toNSString() const
从QString创建一个NSString。 NSString被自动释放。
此功能仅在OS X和iOS上可用。
此功能在Qt 5.2中引入。
short QString::toShort(bool *ok =nullptr, int base = 10) const
返回使用base base转换为short的字符串,默认情况下为10,且必须介于2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toShort()。
例如:
QString str = “FF”;
bool ok;

short hex = str.toShort(&amp;ok, 16);   // hex == 255, ok == true
short dec = str.toShort(&amp;ok, 10);   // dec == 0, ok == false

此函数忽略前导和尾随空格。
另请参见number(),toUShort(),toInt()和QLocale :: toShort()。
std::string QString::toStdString() const
返回带有此QString中包含的数据的std :: string对象。使用toUtf8()函数将Unicode数据转换为8位字符。
此方法对于将QString传递给接受std :: string对象的函数很有用。
另请参见toLatin1(),toUtf8(),toLocal8Bit()和QByteArray :: toStdString()。
std::u16string QString::toStdU16String() const
返回带有此QString中包含的数据的std :: u16string对象。 Unicode数据与utf16()方法返回的数据相同。
此功能在Qt 5.5中引入。
另请参见utf16(),toStdWString()和toStdU32String()。
std::u32string QString::toStdU32String() const
返回带有此QString中包含的数据的std :: u32string对象。 Unicode数据与toUcs4()方法返回的数据相同。
此功能在Qt 5.5中引入。
另请参见toUcs4(),toStdWString()和toStdU16String()。
std::wstring QString::toStdWString() const
返回带有此QString中包含的数据的std :: wstring对象。在wchar_t为2字节宽的平台(例如Windows)上,在utf16中编码std :: wstring;在wchar_t为4字节宽的平台(大多数Unix系统)上,在ucs4中编码。
此方法对于将QString传递给接受std :: wstring对象的函数很有用。
另请参见utf16(),toLatin1(),toUtf8(),toLocal8Bit(),toStdU16String()和toStdU32String()。
uint QString::toUInt(bool ok = nullptr, int base = 10) const
返回使用base base转换为unsigned int的字符串,默认值为10,且必须介于2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toUInt()
例如:
QString str = “FF”;
bool ok;

uint hex = str.toUInt(&amp;ok, 16);     // hex == 255, ok == true
uint dec = str.toUInt(&amp;ok, 10);     // dec == 0, ok == false

此函数忽略前导和尾随空格。
另请参见number(),toInt()和QLocale :: toUInt()。
ulong QString::toULong(bool ok =nullptr, int base = 10) const
返回使用基数base转换为无符号长整数的字符串,默认情况下为10,且必须介于2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toULongLong()。
例如:
QString str = “FF”;
bool ok;

ulong hex = str.toULong(&amp;ok, 16);   // hex == 255, ok == true
ulong dec = str.toULong(&amp;ok, 10);   // dec == 0, ok == false

此函数忽略前导和尾随空格。
另请参见number()和QLocale :: toUInt()。
qulonglong QString::toULongLong(bool ok = nullptr, int base = 10) const
返回使用base base转换为无符号long long的字符串,默认情况下为10,且必须介于2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toULongLong()
例如:
QString str = “FF”;
bool ok;

quint64 hex = str.toULongLong(&amp;ok, 16);    // hex == 255, ok == true
quint64 dec = str.toULongLong(&amp;ok, 10);    // dec == 0, ok == false

此函数忽略前导和尾随空格。
另请参见number(),toLongLong()和QLocale :: toULongLong()。
ushort QString::toUShort(bool ok =nullptr, int base = 10) const
返回使用base base转换为无符号short的字符串,默认为10,且必须介于2到36之间,或者为0。如果转换失败,则返回0。
如果ok不是nullptr,则通过将
ok设置为false来报告失败,而通过将* ok设置为true来报告成功。
如果base为0,则使用C语言约定:如果字符串以“ 0x”开头,则使用base 16;否则,使用16。如果字符串以“ 0”开头,则以8为底。否则,使用基数10。
字符串转换将始终在“ C”区域设置中进行。对于与语言环境相关的转换,请使用QLocale :: toUShort()
例如:
QString str = “FF”;
bool ok;

ushort hex = str.toUShort(&amp;ok, 16);     // hex == 255, ok == true
ushort dec = str.toUShort(&amp;ok, 10);     // dec == 0, ok == false

此函数忽略前导和尾随空格。
另请参见number(),toShort()和QLocale :: toUShort()。
QVector QString::toUcs4() const
以QVector 的形式返回字符串的UCS-4 / UTF-32表示形式。
UCS-4是Unicode编解码器,因此它是无损的。该字符串中的所有字符都将以UCS-4编码。此字符串中任何无效的代码单元序列都将被Unicode的替换字符(QChar :: ReplacementCharacter所对应,它对应于U + FFFD)替换。
返回的向量不是’\ 0’终止的。
此功能在Qt 4.2中引入。
另请参见fromUtf8(),toUtf8(),toLatin1(),toLocal8Bit(),QTextCodec,fromUcs4()和toWCharArray()。
QString QString::toUpper() const
返回字符串的大写副本。
QString str = “TeXt”;
str = str.toUpper(); // str == “TEXT”
大小写转换将始终在“ C”区域设置中进行。对于与
语言环境相关的大小写折叠,请使用QLocale :: toUpper()
另请参见toLower()和QLocale :: toLower()。
QByteArray QString::toUtf8() const
以QByteArray形式返回字符串的UTF-8表示形式。
UTF-8是Unicode编解码器,可以表示Unicode字符串(如QString)中的所有字符。
另请参见fromUtf8(),toLatin1(),toLocal8Bit()和QTextCodec。
int QString::toWCharArray(wchar_t array) const
用此QString对象中包含的数据填充array。在wchar_t为2字节宽的平台(例如Windows)上,该数组以UTF-16编码;在wchar_t为4字节宽的平台(大多数Unix系统)上,以UCS-4编码。
array必须由调用方分配,并包含足够的空间来容纳完整的字符串(以与字符串相同的长度分配数组总是足够的)。
此函数返回数组中字符串的实际长度。
注意:此函数不会将空字符附加到数组。
功能在Qt 4.2中引入。
另请参见utf16(),toUcs4(),toLatin1(),toUtf8(),toLocal8Bit(),toStdWString()和QStringView :: toWCharArray()。
QString QString::trimmed() const
返回从开头和结尾删除空格的字符串。
空格表示QChar :: isSpace()返回true的任何字符。这包括ASCII字符 ‘\t’, ‘\n’, ‘\v’, ‘\f’, ‘\r’, 和 ‘ ‘.
例如:
QString str = ” lots\t of\nwhitespace\r\n “;
str = str.trimmed();
// str == “lots\t of\nwhitespace”
与simpleized()不同,trimmed()仅保留内部空白。
另请参见 simplified().
void QString::truncate(int position)
在给定位置索引处截断字符串。
如果指定的位置索引超出字符串的末尾,则不会发生任何事情。
例如:
QString str = “Vladivostok”;
str.truncate(4);
// str == “Vlad”
如果position为负,则等于传递零。
另请参见chop(),resize(),left()和QStringRef :: truncate()。
const QChar *QString::unicode() const
返回字符串的Unicode表示形式。在字符串被修改之前,结果一直有效。
注意:返回的字符串不能以’\ 0’结尾。使用size()确定数组的长度。
另请参见setUnicode(),utf16()和fromRawData()。
const ushort *QString::utf16() const
将QString返回为以’\ 0’终止的无符号短裤数组。在字符串被修改之前,结果一直有效。
返回的字符串按主机字节顺序。
另请参见setUtf16()和unicode()。
QString QString::vasprintf(const char *cformat, va_list ap)
与asprintf()等效的方法,但采用va_list ap代替变量参数列表。有关cformat的说明,请参见asprintf()文档。
此方法不调用va_end宏,调用方负责在ap上调用va_end。
此功能在Qt 5.5中引入。
另请参见asprintf()。
bool QString::operator!=(QLatin1String other) const
如果此字符串不等于参数字符串other,则返回true。否则返回false。
此函数重载operator!=()。
bool QString::operator!=(const char *other) const
此函数重载operator!=()。
使用fromUtf8()函数将const char
other转换为QString。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator!=(const QByteArray &other) const
此函数重载operator!=()。
使用fromUtf8()函数将other字节数组转换为QString。如果在字节数组中嵌入了任何NUL字符(’\ 0’),则它们将包含在转换中。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QString &QString::operator+=(QChar ch)
此函数重载operator + =()。
将字符ch附加到字符串。
QString &QString::operator+=(const QString &other)
将other字符串附加到该字符串的末尾,并返回对该字符串的引用。
例如:
QString x = “free”;
QString y = “dom”;
x += y;
// x == “freedom”
此操作通常非常快(恒定时间),因为QString在字符串数据的末尾预分配了额外的空间,因此它可以增长而不必每次都重新分配整个字符串。
另请参见append()和prepend()。
QString &QString::operator+=(const QStringRef &str)
此函数重载operator + =()。
将str引用的字符串部分追加到此字符串。
QString &QString::operator+=(QLatin1String str)
此函数重载operator + =()。
将Latin-1字符串str附加到此字符串。
QString &QString::operator+=(const char str)
此函数重载operator + =()。
将字符串str追加到此字符串。使用fromUtf8()函数将const char指针转换为Unicode。
您可以在编译应用程序时通过定义QT_NO_CAST_FROM_ASCII来禁用此功能。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QString &QString::operator+=(const QByteArray &ba)
此函数重载operator + =()。
将字节数组ba附加到此字符串。使用fromUtf8()函数将字节数组转换为Unicode。如果在ba字节数组中嵌入了任何NUL字符(’\ 0’),则它们将包含在转换中。
您可以在编译应用程序时通过定义QT_NO_CAST_FROM_ASCII来禁用此功能。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QString &QString::operator+=(char ch)
此函数重载operator + =()。
将字符ch附加到此字符串。请注意,该字符使用fromLatin1()函数转换为Unicode,这与对UTF-8数据进行操作的其他8位函数不同。
您可以在编译应用程序时通过定义QT_NO_CAST_FROM_ASCII来禁用此功能。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator<(QLatin1String other) const
此函数重载operator <()。
如果此字符串在词法上小于称为other的参数字符串,则返回true;否则返回true。否则返回false。
bool QString::operator<(const char *other) const
如果此字符串在词法上小于other字符串,则返回true。否则返回false。
此函数重载operator <()。
使用fromUtf8()函数将const char
other转换为QString。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator<(const QByteArray &other) const
此函数重载operator <()。
使用fromUtf8()函数将other字节数组转换为QString。如果在字节数组中嵌入了任何NUL字符('\ 0'),则它们将包含在转换中。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator<=(QLatin1String other) const
如果此字符串在词法上小于或等于参数字符串other,则返回true。否则返回false。
此函数重载operator <=()。
bool QString::operator<=(const char other) const
此函数重载operator <=()。
使用fromUtf8()函数将const char
other转换为QString。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator<=(const QByteArray &other) const
此函数重载operator (QLatin1String other) const
此函数重载operator>()。
如果此字符串在词法上大于参数字符串other,则返回true;否则,返回false
bool QString::operator>(const char other) const
此函数重载operator>()。
使用fromUtf8()函数将const char
other转换为QString。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator>(const QByteArray &other) const
此函数重载operator>()。
使用fromUtf8()函数将other字节数组转换为QString。如果在字节数组中嵌入了任何NUL字符(’\ 0’),则它们将包含在转换中。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator>=(QLatin1String other) const
如果此字符串在词法上大于或等于参数字符串other,则返回true。否则返回false。
此函数重载operator> =()。
bool QString::operator>=(const char other) const
此函数重载operator> =()。
使用fromUtf8()函数将const char
other转换为QString。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用
另请参见QT_NO_CAST_FROM_ASCII。
bool QString::operator>=(const QByteArray &other) const
此函数重载operator> =()。
使用fromUtf8()函数将other字节数组转换为QString。如果在字节数组中嵌入了任何NUL字符(’\ 0’),则它们将包含在转换中。
编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用此运算符。例如,如果要确保所有用户可见的字符串都通过QObject :: tr(),则此功能很有用。
另请参见QT_NO_CAST_FROM_ASCII。
QCharRef QString::operator[](int position)
返回字符串中指定的字符position作为可修改的引用。
例如:
QString str;

if (str[0] == QChar('?'))
    str[0] = QChar('_');

返回值是QCharRef类型,它是QString的帮助程序类。当您获得类型为QCharRef的对象时,可以将其用作对QChar的引用。如果分配给它,则分配将应用于从中获取引用的QString中的字符。
注意:在Qt 5.14之前,可以使用此运算符在字符串的越界位置访问字符,然后分配给该位置,从而自动调整字符串的大小。此外,即使同时已复制了字符串(并且在进行复制时QCharRef仍保持活动状态),将值分配给返回的QCharRef也会导致字符串分离。这些行为已被弃用,并将在以后的Qt版本中进行更改。
另请参见at()。
const QChar QString::operator[](int position) const
此函数重载operator []()。
const QChar QString::operator[](uint position) const
等效于at(position)。
此函数重载operator []()。
QCharRef QString::operator[](uint position)
此函数重载operator []()。
返回字符串中指定的字符position作为可修改的引用。Related Non-Members
bool operator!=(const QString &s1,const QString &s2)
如果字符串s1不等于字符串s2,则返回true;否则返回false。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用localeAwareCompare()对用户界面字符串进行排序。
bool operator!=(const char *s1,const QString &s2)
如果s1不等于s2,则返回true;否则返回false。
对于s1!= 0,这等效于compare(s1,s2)!=0。请注意,没有字符串等于s1为0。
const QString operator+(const QString &s1, const QString &s2)
返回一个字符串,该字符串是s1和s2串联的结果。
const QString operator+(const QString &s1, const char *s2)
返回一个字符串,该字符串是s1和s2串联的结果(使用QString :: fromUtf8()函数将s2转换为Unicode)。
另请参见QString :: fromUtf8()。
const QString operator+(const char *s1, const QString &s2)
返回一个字符串,该字符串是s1和s2串联的结果(使用QString :: fromUtf8()函数将s1转换为Unicode)。
另请参见QString :: fromUtf8()。
const QString operator+(char ch,const QString &s)
返回一个字符串,该字符串是将字符ch和字符串s连接在一起的结果。
const QString operator+(const QString &s, char ch)
返回一个字符串,该字符串是将字符串s和字符ch连接在一起的结果。
bool operator<(const QString &s1,const QString &s2)
如果字符串s1在词法上小于字符串s2,则返回true否则返回false。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用QString :: localeAwareCompare()函数对用户界面字符串进行排序。
bool operator<(const char *s1,const QString &s2)
如果s1在词法上小于s2,则返回true;否则返回false。对于s1!= 0,这等效于compare(s1,s2)<0。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用QString :: localeAwareCompare()函数对用户界面字符串进行排序。
QDataStream &operator<<(QDataStream &stream, const QString &string)
将给定的string写入指定的stream。
另请参见 Serializing Qt Data Types.。
bool operator<=(const QString &s1,const QString &s2)
如果字符串s1在词法上小于或等于字符串s2,则返回true;否则返回false。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用localeAwareCompare()对用户界面字符串进行排序。
bool operator<=(const char *s1,const QString &s2)
如果s1在词法上小于或等于s2,则返回true;否则返回false。对于s1!= 0,这等效于compare(s1,s2)(const QString &s1,const QString &s2)
如果字符串s1在词法上大于字符串s2,则返回true;否则返回false。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用localeAwareCompare()对用户界面字符串进行排序
bool operator>(const char *s1,const QString &s2)
如果s1在词法上大于s2,则返回true;否则返回false。等效于compare(s1,s2)> 0。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用QString :: localeAwareCompare()函数对用户界面字符串进行排序。
bool operator>=(const QString &s1,const QString &s2)
如果字符串s1在词法上大于或等于字符串s2,则返回true;否则返回false。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用localeAwareCompare()对用户界面字符串进行排序。
bool operator>=(const char *s1,const QString &s2)
如果s1在词法上大于或等于s2,则返回true;否则返回false。对于s1!= 0,这等效于compare(s1,s2)> = 0。
这种比较仅基于字符的Unicode数字值,并且比较快,但不是人们期望的。考虑使用QString :: localeAwareCompare()函数对用户界面字符串进行排序。
QDataStream &operator>>(QDataStream &stream, QString &string)
从指定的流中将字符串读取到给定的string中。
另请参见 Serializing Qt Data Types.

Macro Documentation
QStringLiteral(str)
宏在编译时从字符串文字str中为QString生成数据。在这种情况下,可以从中免费创建QString,并且将生成的字符串数据存储在已编译目标文件的只读段中。
如果您的代码如下所示:
// hasAttribute takes a QString argument
if (node.hasAttribute(“http-contents-length”)) //…
然后将创建一个临时QString作为hasAttribute函数参数传递。这可能会非常昂贵,因为它涉及内存分配以及将数据复制/转换为QString的内部编码。
通过使用QStringLiteral可以避免此成本:
if (node.hasAttribute(QStringLiteral(u”http-contents-length”))) //…
在这种情况下,QString的内部数据将在编译时生成。在运行时不会发生任何转换或分配。
使用QStringLiteral而不是用双引号引起来的纯C ++字符串文字可以显着加快根据编译时已知的数据创建QString实例的速度。
注意:当将字符串传递给具有重载QLatin1String的函数时,QLatin1String仍比QStringLiteral更有效,并且此重载可避免转换为QString。例如,QString :: operator ==()可以直接与QLatin1String进行比较:
if (attribute.name() == QLatin1String(“http-contents-length”)) //…
注意:某些编译器的bug编码字符串包含US-ASCII字符集以外的字符。在这种情况下,请确保在字符串前加上u。否则是可选的。
另请参见QByteArrayLiteral。
QT_NO_CAST_FROM_ASCII
禁用从8位字符串(char *)到Unicode QStrings的自动转换
另请参见QT_NO_CAST_TO_ASCIIQT_RESTRICTED_CAST_FROM_ASCII和QT_NO_CAST_FROM_BYTEARRAY。
QT_NO_CAST_TO_ASCII
禁用从QString到8位字符串(char *)的自动转换
另请参见QT_NO_CAST_TO_ASCIIQT_RESTRICTED_CAST_FROM_ASCII和QT_NO_CAST_FROM_BYTEARRAY。
QT_RESTRICTED_CAST_FROM_ASCII
定义此宏将禁用从源文字和8位数据到Unicode QString的大多数自动转换,但允许使用QChar(char)和QString(const char(&ch)[N]构造函数,以及QString :: operator =( const char(&ch)[N])赋值运算符,提供了QT_NO_CAST_FROM_ASCII的大多数类型安全优点,但不需要用户代码使用QLatin1Char,QLatin1String或类似字符包装字符和字符串文字。
未定义将此宏与7位范围以外的源字符串,非文字或带有嵌入式NUL字符的文字一起使用。
另请参见QT_NO_CAST_FROM_ASCII和QT_NO_CAST_TO_ASCII。

Leave a Comment