qstring_zh
2022-04-07 14:42:49

Class::QString

暂无该属性


Detailed Description

QString 类提供了一个 Unicode 字符的字符串。 QString 存储一串16位的 QChar ,其中每一个 QChar 对应一个 UTF-16 的代码单元 。(Unicode 值大于65535的字符使用对代替,即用两个 QChar 来存储)。

Unicode 是一个国际标准,支持当今使用的大多数书写系统。它是 US-ASCII(ANSI X3.4-1986)和 Latin-1(ISO 8859-1)的超集,并且所有 US-ASCII/Latin-1 字符都位于相同的代码位置。

实际上, QString 使用 implicit sharing (写拷贝)来减少内存使用并避免不必要的数据复制。这也有助于减少存储16位字符而不是8位字符的固有开销。

除了 QString 之外,Qt 还提供了 QByteArray 类来存储原始字节和传统的以8位‘\0‘结束的字符串。在大多数情况下,还是推荐使用 QString 。它贯穿整个 Qt API,而且对 Unicode 支持可方便翻译成其它语言。主要适用两种情况:存储原始二进制数据时,以及保留至关重要的内存时(例如在嵌入式系统中)。

初始化字符串

初始化 QString 的一种方法就是将一个const char *类型传给其构造函数。例如,以下代码创建一个长度为5的 QString ,其中包含数据“Hello”:

QString 通过const char *使用函数将数据转换为 Unicode 格式。

在所有参数是const char *类型的 QString 函数中,均被解释为以 UTF-8 编码的经典 C 风格‘\0‘结束的字符串。当参数是const char *类型时,传nullptr也是合法的。

也可以用 QChar 数组提供字符串数据:

QString 会对 QChar 数据进行深度复制,可以在后面修改它而不会出现副作用。(如果出于性能原因,不想复制字符数据的深层副本,请使用 QString::fromRawData() 代替。)

另一种方法是使用 resize() 设置字符串的大小,并对每个字符的数据进行初始化。 QString 使用基于0的索引,像 C++ 数组一样。要访问特定索引位置的字符,可以使用 operator 。在非 const 字符串上, operator 返回一个字符的引用,可以在赋值的左侧使用。例如:

对于只读访问,可以是使用另一种 at() 函数。

at() 函数比 operator 更快,因为它不会 deep copy 的。另外,使用 left()right()mid() 函数可以一次提取多个字符。

QString 可以嵌入‘\0‘字符( QChar::Null )。 size() 函数总是返回整个字符串的大小,包括嵌入的‘\0‘字符。

调用 resize() 函数后,新分配的字符有未定义的值。要将字符串中的所有字符设置为特定的值,可以使用 fill() 函数。

QString 提供了数十种重载,旨在简化字符串的使用。例如,如果想比较一个 QString 和一个文字字符串,可以写这样的代码,它将会像预期的那样工作。

也可以通过调用 QString (const char *) 构造函数,将文字字符串传递给以 QStrings 为参数的函数。同样,也可以使用 qPrintable() 宏将一个 QString 传递给一个以const char *为参数的函数,该函数将以const char *的形式返回给定的 QString 。这相当于调用 QString . toLocal8Bit() . constData()

处理字符串数据

QString 提供了以下修改字符数据的基本函数: append()prepend()prepend()insert()replace()remove() 。例如:

如果正在创建一个 QString ,并且事先知道 QString 大约会包含多少个字符,可以调用 reserve() ,要求 QString 预分配一定量的内存。也可以调用 capacity() 来了解 QString 实际分配了多少内存。

replace()remove() 函数的前两个参数是开始擦除的位置和应该被擦除的字符个数。如果想用另一个特定的子串替换所有出现的字符,可以使用一个双参数的 replace() 重载。

一个常见的要求是从字符串中删除空白符(‘\n’,‘\t’,‘ ‘等)。如果想从一个 QString 的两端删除空白符,使用 trimmed() 函数。如果想从字符串的两端去掉空白符,并在字符串中用一个空格字符替换多个连续的空格,使用 simplified() 函数。

如果想在一个 QString 中找到一个特定字符或子串,可以使用 indexOf()lastIndexOf() 函数。前者从给定的索引位置开始从前往后搜索,后者是从后往前搜索。如果找到了字符或字符串,两者都返回它的索引位置;否则,返回-1。例如,这里是一个典型的循环,它可以找到一个特定字符串所有出现的位置。

QString 提供了许多将数字和字符串互相转换的函数。参见 arg() 函数, setNum() 函数, setNum() 静态函数,以及 toInt()toDouble() 和类似函数。

要获得一个字符串全部字符的大小写,请使用 toUpper()toLower()

字符串列表由 QStringList 类处理。可以使用 split() 函数将一个字符串分割成一个字符串列表,并使用 QStringList::join() 将一个字符串列表连接成一个带有可选分隔符的单一字符串。可以使用 QStringList::filter() 函数从一个字符串列表中获得一个包含特定子串或匹配特定 QRegExp 的字符串列表。

查询字符串数据

如果想查看一个 QString 是否以一个特定的字符串开始或结束,使用 startsWith()endsWith() 函数。如果只是想检查一个 QString 是否包含一个特定的字符或子串,使用 contains() 函数。如果想知道一个特定的字符或子串在字符串中出现了多少次,则使用 count()

要获字符数据的指针,可以调用 data()constData() 。这些函数返回一个指向 QChar 数据开头的指针。在 QString 上调用一个非 const 函数之前,这个指针都是有效的。

比较字符串

QStrings 可以使用重载运算符进行比较,如 operator<()operator<=()operator==()operator>=() 等。注意,比较完全是基于字符的 Unicode 数字值。它的速度非常快,但并不是我们所期望的;根据用户界面字符串比较请考虑使用 QString::localeAwareCompare()

在类 Unix 的平台上(包括 Linux、macOS 和 iOS),当 Qt 与 ICU 库链接时(通常是这样),会使用它的本地排序。否则,在 macOS 和 iOS 上, localeAwareCompare() 会根据“国际首选项”面板中的"排序列表的顺序"设置进行比较。在其它没有 ICU 的类 Unix 的系统上或者考虑使用本地比较时,则会调用系统库的strcoll()

在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 使用起来更加方便,但是总是存在着使用错误的8位编码从 const char * 到const char *的隐式转换的风险。为了将这些风险降到最低,可以通过定义以下一些预处理器符号来关闭这些隐式转换。

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

同样,必须显式调用 toLatin1()toUtf8()toLocal8Bit() 来将 QString 转换为8位字符串。(通过类支持其它编码。)

C 程序员注意事项

由于 C++ 的类型系统和QStringimplicitly shared的,字符串可以像int或其它基本类型一样对待。例如:

result变量是在堆栈上分配的普通变量。当return被调用时,由于我们要按值返回,因此将调用复制构造函数,并返回字符串的副本。由于隐式共享,因此不会进行实际的复制。

Null 和空字符串之间的区别

由于历史原因, QString 对 null 和空字符串是有区分。null 是指使用 QString 的默认构造函数或通过传递( const char *)0给构造函数来初始化的字符串。空字符串是任何大小为0的字符串。null 总是空字符串,但空字符串不一定是 null。

除了 isNull() 以外的所有函数都把 null 当作空字符串处理。例如, toUtf8() . constData() 对空字符串返回一个有效的指针(而不是 nullptr)指向‘\0’字符。建议使用 isEmpty() 函数,避免使用 isNull()

参数格式

在可以指定参数格式的成员函数中(例如 arg()number() ),参数格式可以是以下之一。

格式

意义

e

格式为 [-] 9.9e [+ |-] 999

E

格式为 [-] 9.9E [+ |-] 999

f

格式为 [-] 9.9

g

使用ef格式,以最简洁的为准

G

使用Ef格式,以最简洁的为准

参数格式中指定了精度。对于‘e’、‘E’和‘f’格式,精度代表小数点的数字。对于‘g’和‘G’格式,精度代表最大的显性数位(尾部的零被省略)。

更高效的字符串构造函数

许多字符串在编译时都是已知的。但琐碎的构造函数 QString ("Hello"),会复制字符串的内容,将内容视为 Latin-1。为了避免这种情况,可以使用 QStringLiteral 宏在编译时直接创建所需数据。这样在运行时,从 literal 中构造一个 QString 就不会造成任何开销。

一个效率稍低的方法是使用 QLatin1String 。这个类封装了一个 C 字符串的文字,在编译时预先计算它的长度,然后可以用来比普通的 C 字符串文字更快地与 QStrings 进行比较并转换为字符串。

使用 QString '+'操作符,可以更容易地从多个字符串中构造一个复杂的字符串。

这两种字符串结构都没有错,但有一些效果会比较低。从 Qt 4.6开始,可以移除它们。

首先,多次使用'+'运算符通常意味着多次内存分配。当连接 n 个子串(其中n > 2)时,对内存分配器的调用可能多达n - 1次。

在4.6中,增加了一个内部模板类QStringBuilder和一些辅助函数。这个类被标记为内部类,并没有出现在文档中,因为不打算在代码中实例化它。它将自动使用,如下所述。如果想看看这个类,可以在src/corelib/tools/qstringbuilder.cpp中找到它。

QStringBuilder使用表达式模板并重新实现了'%'操作符,因此当使用'%'代替'+'进行字符串连接时,多个字符串连接将被推迟,直到最终结果即将被分配到一个 QString 中。此时,最终结果所需的内存量是已知的。然后调用内存分配器一次,得到所需的空间,然后将字符串逐个复制到其中。

通过内联和减少引用计数获得了额外的效率(从QStringBuilder创建的 QString 通常有1个引用计数,而 QString::append() 需要一个额外的测试)。

有两种方法可以使用这种改进的字符串构造方法。直接的方法是在想使用它的地方加入QStringBuilder,并在连接字符串时使用'%'操作符代替'+'

一个更全面的方法是在 .pro 文件中定义,这是最方便的,但代码兼容性不好。

'+'将自动作为QStringBuilder'%'到处执行。

超大和内存溢出情况下

当前版本的 QString 的大小限制在2GB(2^31字节)以下。确切的数值取决于架构,因为它取决于管理数据块所需的开销,但不超过32字节。原始数据块在当前版本中也因为使用int类型而被限制在2GB减去1个字节的范围内。由于 QString 每个字符使用2个字节,所以相当于一个 QString 中只有不到2^30个字符。

在内存分配失败的情况下, QString 会抛出一个std::bad_alloc异常。Qt 容器中的内存不足是 Qt 唯一会抛出异常的情况。

请注意,操作系统可能会对持有大量分配的内存施加进一步的限制,特别是大的、连续块的应用程序。这种行为的配置或任何缓解都在 Qt API 的考虑范围之外。

See also fromRawData() QChar QLatin1String QByteArray QStringRef

QString::QString

[public constructor  ]

QString() 构造一个 null 字符串

See also isEmpty()

QString::QString

[public constructor  ]

QString(const QChar *unicode, int size) 构造一个字符串,并把它初始化为 QChar 数组_unicode_的前_size_部分。

如果_unicode_为0,则构造一个空字符串。

如果_size_为负值,则假设_unicode_指向一个以‘\0‘结束的数组,其长度由动态确定。终止的空字符不被认为是字符串的一部分。

QString 对字符串数据进行深度复制。unicode 数据按原样复制,如果存在字节序号,则保留字节序号。

See also fromRawData()

QString::QString

[public constructor  ]

QString(QChar ch) 构造一个包含字符的_size_为1的字符串。

QString::QString

[public constructor  ]

QString(int size, QChar ch) 构造一个给定_size_的字符串,每个字符都设置为_ch_。

See also fill()

QString::QString

[public constructor  ]

QString(QLatin1String str) 构造一个 Latin-1 字符串_str_的副本。

See also fromLatin1()

QString::QString

[public constructor  ]

QString(const QString &other) 构造一个_str_的副本。

这个操作需要恒定的时间,因为 QString 是隐式共享的。这使得从函数中返回一个 QString 的速度非常快。如果一个共享实例被修改,它将被复制(copy-on-write),这需要线性时间。

See also operator=()

QString::QString

[public move-constructor  ]

QString(QString &&other) Move-constructs 一个 QString 实例,使其指向_other_对象的同一个对象。

QString::QString

[public constructor  ]

QString(const char *str) 构造一个用8位字符串_str_初始化的字符串。给定的 const char 指针使用 fromUtf8() 函数转换为 Unicode。

当编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用这个构造函数。例如,如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

注意:定义QT_RESTRICTED_CAST_FROM_ASCII也会禁用这个构造函数,但会启用QString(const char (&ch)[N])构造函数。在这种情况下,使用 non-literal 输入,或者使用内嵌 NUL 字符的输入,或者使用 non-7-bit 字符的输入是没有定义的。

See also fromLatin1() fromLocal8Bit() fromUtf8() QT_NO_CAST_FROM_ASCII QT_RESTRICTED_CAST_FROM_ASCII

QString::QString

[public constructor  ]

QString(const QByteArray &ba) 用字节数组_ba_初始化的字符串。用字节数组的 fromUtf8() 转换为 Unicode。直到复制第一个0字符,否则复制整个字节数组。

编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCII来禁用这个构造函数。例如,如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also fromLatin1() fromLocal8Bit() fromUtf8() QT_NO_CAST_FROM_ASCII

QString::QString

[private constructor  ]

QString(const QString::Null &)

QString::QString

[private constructor  ]

QString(int size, Qt::Initialization )

QString::QString

[private constructor  ]

QString(QStringDataPtr dd)

暂无该属性

[public macrowithparams  ]

QStringLiteral( str) 该宏在编译时从字符串文字_str_中生成 QString 的数据。在这种情况下,创建一个 QString 是很快且不耗资源的,生成的字符串数据被存储在编译对象文件的只读段中。

如果代码看起来像这样:

然后创建一个临时的 QString 作为hasAttribute函数的参数。这可能是相当耗资源的,因为它涉及到内存分配和将数据复制/转换为 QString 的内部编码。

这个成本可以通过使用代替来避免:

在这种情况下, QString 的内部数据将在编译时生成;在运行时不会发生转换或分配。

使用代替双引号的普通 C++ 字符串文字可以显著加快从编译时已知数据创建 QString 实例的速度。

注意: QLatin1String 仍然可以比将字符串传递给一个有重载取 QLatin1String 的函数,而这个重载避免了转换为 QString ,效率更高。例如,QString::operator==() 可以直接与 QLatin1String 进行比较。

注意:有些编译器对包含 US-ASCII 字符集以外字符的字符串进行编码时有错误。在这种情况下,请确保字符串前缀为u。否则是可选的。

See also QByteArrayLiteral

暂无该属性

[private macrowithoutparams  ]

QT_ASCII_CAST_WARNINGS 这个宏可以被定义为每当调用一个在 unicode 和8位编码之间自动转换的函数时强制发出警告。

注意:这只适用于支持废弃 API 警告的编译器。

See also QT_NO_CAST_TO_ASCII QT_NO_CAST_FROM_ASCII QT_RESTRICTED_CAST_FROM_ASCII

暂无该属性

[public macrowithoutparams  ]

QT_NO_CAST_FROM_ASCII 禁用从8位字符串 (char *) 到 unicode QStrings 的自动转换。

See also QT_NO_CAST_TO_ASCII QT_RESTRICTED_CAST_FROM_ASCII QT_NO_CAST_FROM_BYTEARRAY

暂无该属性

[public macrowithoutparams  ]

QT_NO_CAST_TO_ASCII 禁止将 QString 自动转换为8位字符串 (char *)。

See also QT_NO_CAST_FROM_ASCII QT_RESTRICTED_CAST_FROM_ASCII QT_NO_CAST_FROM_BYTEARRAY

暂无该属性

[public macrowithoutparams  ]

QT_RESTRICTED_CAST_FROM_ASCII 禁用大部分从源 literals 和8位数据到 unicode QStrings 的自动转换,但允许使用QChar(char)QString(const char (&ch)[N]构造函数,以及QString::operator=(const char (&ch)[N])赋值运算符。这提供了QT_NO_CAST_FROM_ASCII的大部分类型安全优势,但不需要用户代码用 QLatin1Char 、或类似的方式来包装字符和字符串

将此宏与7位范围外的字符串、 non-literals 或内嵌 NUL 字符的一起使用是没有定义的。

See also QT_NO_CAST_FROM_ASCII QT_NO_CAST_TO_ASCII

QString::append

[public plain  ]

QString & append(const QString &str) 将字符串_str_附加到这个字符串的末端。

例如:

这和使用 insert() 函数是一样的。

该函数通常非常快(恒定时间),因为 QString 在字符串数据的末尾预分配了额外的空间,所以它可以增长,而不需要每次重新分配整个字符串。

See also operator+=() prepend() insert()

QString::append

[public plain  ]

QString & append(QChar ch) 这个函数重载了 append()

将字符_ch_附加到这个字符串上。

QString::append

[public plain  ]

QString & append(const QChar *str, int len) 这个函数重载了 append()

QChar 数组_str_中的_len_字符添加到这个字符串中。

QString::append

[public plain  ]

QString & append(const QStringRef &reference) 将字符串_reference_引追加到这个字符串上,并返回结果。

QString::append

[public plain  ]

QString & append(QLatin1String str) 这个函数重载了 append()

将 Latin-1 字符串_str_追加到这个字符串上。

QString::append

[public plain  ]

QString & append(QStringView str) 将给定的字符串_str_加到这个字符串之后,并返回结果。

注意:5.15.2中增加了这个方法,以方便在 Qt 5.15 和 Qt 6 之间代码移植。

QString::append

[public plain  ]

QString & append(const char *str) 这个函数重载了 append()

将字符串_str_追加到这个字符串上。给定的 const char* 使用 fromUtf8() 函数转换为 Unicode。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个函数。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::append

[public plain  ]

QString & append(const QByteArray &ba) 这个函数重载了 append()

将 const QByteArray &_ba_添加到字符串中。给定的字节数组使用 fromUtf8() 函数转换为 Unicode。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个函数。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::arg

[public plain  ]

QString arg(const QString &a, int fieldWidth, QChar fillChar) const 回这个字符串的副本,用字符串_a_替换最低编号的位置标记,即%1%2,...,%99

_fieldWidth_指定参数_a_所占空间的最小值。如果参数_a_需要的空间小于_fieldWidth_,则用字符_fieldWidth_将其填充到_fieldWidth_。_fieldWidth_大于0是右对齐的文本。_fieldWidth_小于0左对齐的文本。

这个例子展示了如何在处理文件列表时创建一个status字符串来报告进度:

首先,arg(i)代替%1。然后,arg(total)替换%2。最后,arg(fileName)替换%3

使用 asprintf() 的好处是,如果应用程序的字符串被翻译成其它语言,那么编号的位置标记的顺序可以改变,但每个位置标记仍然会替换最低编号的未替换的位置标记,无论它出现在哪里。另外,如果占位标记在字符串中出现了不止一次,则会替换所有的占位标记。

如果没有剩余的未替换的位置标记,则会输出一条警告信息,结果是未定义的。位置标记的数量必须在1到99的范围内。

QString::arg

[public plain  ]

QString arg(qlonglong a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

参数_a_的显示方式的基于参数_base_。_base_必须在2和36之间,8表示八进制,10表示十进制,16表示十六进制。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(qulonglong a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

将整数_a_转换为字符串时要使用的参数_base_。_base_必须在2和36之间,8表示八进制,10表示十进制,16表示十六进制。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(long a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

参数_a_的显示方式是基于参数_base_,参数_base_默认为10,必须在2和36之间。

‘%’后面可以跟一个‘L’,在这种情况下,序列会被替换为_a_的本地化表示。默认的 locale 是由应用程序启动时系统的 locale 设置决定的。它可以使用 QLocale::setDefault() 来改变。如果_base_不是10,‘L’标志将被忽略。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(ulong a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

_base_参数指定了将整数转换为字符串时要使用的基数。_base_必须在2和36之间,8表示八进制,10表示十进制,16表示十六进制。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(int a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

参数_a_的显示方式是基于参数_base_,_base_默认为10,必须在2和36之间。对于10以外的基数,被视为无符号整数。

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

‘%’后面可以跟一个‘L’,在这种情况下,序列会被替换为_a_的本地化表示形式。如果没有指定 QLocale::setDefault() ,则使用 "C" locale。如果_base_不是10,‘L’标志将被忽略。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(uint a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

参数整形 _a_转换成字符串,是根据参数_base_,_base_必须在2和36之间。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(short a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

参数_a_的显示方式的基于参数_base_。_base_必须在2和36之间,8表示八进制,10表示十进制,16表示十六进制。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(ushort a, int fieldWidth, int base, QChar fillChar) const 这个函数重载了 arg()

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

参数_a_的显示方式的基于参数_base_。_base_必须在2和36之间,8表示八进制,10表示十进制,16表示十六进制。

如果_fillChar_是‘0’(数字0,ASCII 48),则使用 locale 的0。对于负数,在减号之前可能会出现0填充。

QString::arg

[public plain  ]

QString arg(double a, int fieldWidth, char format, int precision, QChar fillChar) const 这个函数重载了 arg()

参数_a_按照指定的格式和精度进行格式化。详情请参见 Argument Formats

_fieldWidth_指的是填充字符_fillChar_的最小空间。正值产生右对齐的文本,负值产生左对齐的文本。

‘%’后面可以跟一个‘L’,在这种情况下,序列会被替换为_a_的本地化表示形式。如果没有指定 QLocale::setDefault() ,则使用 "C" locale。

如果_fillChar_是‘0’(数字0,ASCII 48),这个函数将使用 locale 的0来填充。对于负数,0的填充可能会出现在减号之前。

See also QLocale::toString()

QString::arg

[public plain  ]

QString arg(char a, int fieldWidth, QChar fillChar) const 这个函数重载了 arg()

参数_a_被解释为 Latin-1 类型的字符。

QString::arg

[public plain  ]

QString arg(QChar a, int fieldWidth, QChar fillChar) const 这个函数重载了 arg()

QString::arg

[public plain  ]

QString arg(QStringView a, int fieldWidth, QChar fillChar) const 这是一个重载函数。

返回这个字符串的副本,用字符串_a_替换最低编号的位置标记,即%1%2,...,%99

_fieldWidth_指定了_a_所占空间的最小值,如果_a_需要的空间小于_fieldWidth_,则用字符_fillChar_填充到_fieldWidth_。正的_fieldWidth_会产生右对齐的文本,负的会产生左对齐的文本。

这个例子展示了我们如何在处理文件列表时创建一个status字符串来报告进度。

首先,arg(i)代替%1。然后,arg(total)替换%2。最后,arg(fileName)替换%3

asprintf() 相比,使用 arg() 的好处是,如果应用程序的字符串被翻译成其它语言,数字标记的顺序可以改变,但是每个 arg() 仍然会替换数字最小的未替换的标记,无论它出现在哪里。另外,如果占位符%i在字符串中出现了不止一次,那么 arg() 会替换所有的占位符。

如果没有剩余的未替换的位置标记,则会打印一条警告信息,结果是未定义的。位置标记编号必须在1至99的范围内。

QString::arg

[public plain  ]

QString arg(QLatin1String a, int fieldWidth, QChar fillChar) const 这是一个重载函数。

返回这个字符串的副本,用字符串_a_替换最低编号的位置标记,即%1%2,...,%99

_fieldWidth_指定了_a_所占空间的最小值,如果_a_需要的空间小于_fieldWidth_,则用字符_fillChar_填充到_fieldWidth_。正的_fieldWidth_会产生右对齐的文本,负的_fieldWidth_会产生左对齐的文本。

asprintf() 相比,使用 arg() 的好处是,如果应用程序的字符串被翻译成其它语言,数字标记的顺序可以改变,但是每个 arg() 仍然会替换数字最小的未替换的标记,无论它出现在哪里。另外,如果占位符%i在字符串中出现了不止一次,那么 arg() 会替换所有的占位符。

如果没有剩余的未替换的位置标记,则会打印一条警告信息,结果是未定义的。位置标记编号必须在1至99的范围内。

QString::arg

[public plain  ]

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::arg

[public plain  ]

QString arg(const QString &a1, const QString &a2, const QString &a3) const 这个函数重载了 arg()

这和调用str.arg(a1).arg(a2).arg(a3)是一样的,只不过字符串_a1_、_a2_和_a3_只替换一次。

QString::arg

[public plain  ]

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::arg

[public plain  ]

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_和只替换一次。

QString::arg

[public plain  ]

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::arg

[public plain  ]

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::arg

[public plain  ]

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::arg

[public plain  ]

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_只替换一次。

QString::arg

[public plain  ]

QString arg(Args &&... args) const

QString::asprintf

[public plain static ]

QString asprintf(const char *cformat, ... ) 从格式字符串_cformat_和一个任意的参数列表中安全地建立一个格式化的字符串。

格式字符串支持标准 C++ 库中 printf() 提供的转换指定符、长度修饰符和标志。_cformat_字符串和%s参数必须为 UTF-8 编码。

注意:%lc转义序列期望一个char16_tushort类型的 unicode 字符(由 QChar::unicode() 返回)。%ls转义序列期望一个指向char16_tushort类型的 unicode 字符的零结尾数组的指针(如 QString::utf16() 所返回)。这与标准 C++ 库中的 printf() 不一致,后者定义了%lc用来打印一个wchar_t,而用来打印一个wchar_t*,而且在wchar_t的大小不是16位的平台上也可能产生编译器警告。

警告:不建议在新的 Qt 代码中使用。可以考虑使用 QTextStreamarg() ,这两个函数都无缝地支持 Unicode 字符串,并且是类型安全的。下面是一个使用 QTextStream 的例子:

对于 QObject::tr() ,特别是当字符串包含多个转义序列时,应该考虑使用函数 arg() 来代替。这样可以由译者控制替换的顺序。

See also arg()

QString::at

[public plain  ]

const QChar at(int position) const 返回字符串中给定索引_position_的字符。

_position_必须是字符串中有效的索引位置(0 <= position < size() )。

See also operator

QString::back

[public plain  ]

QChar back() const 返回字符串中的最后一个字符。与at(size() - 1)相同。

此功能是为了兼容 STL 而提供的。

警告:在一个空字符串上调用此函数会构成未定义的行为。

See also front() at() operator

QString::back

[public plain  ]

QCharRef back() 返回字符串中最后一个字符的引用。与operator[](size() - 1)相同。

此功能是为了兼容 STL 而提供的。

警告:在一个空字符串上调用此函数会构成未定义的行为。

See also front() at() operator

QString::begin

[public plain  ]

QString::iterator begin() 返回一个 STL 风格的迭代器,指向字符串中的第一个字符。

See also constBegin() end()

QString::begin

[public plain  ]

QString::const_iterator begin() const 这个函数重载了 begin()

QString::capacity

[public plain  ]

int capacity() const 返回字符串中可存储的最大字符数,并没有实际分配。

这个函数的唯一目的是提供一种微调 QString 内存使用情况的方法。一般来说,很少需要调用这个函数。如果想知道字符串中有多少个字符,调用 size()

See also reserve() squeeze()

QString::cbegin

[public plain  ]

QString::const_iterator cbegin() const 返回一个指向字符串中第一个字符的 STL-style iterators

See also begin() cend()

QString::cend

[public plain  ]

QString::const_iterator cend() const 返回指向列表中最后一个字符后的虚构字符的 STL-style iterators

See also cbegin() end()

QString::chop

[public plain  ]

void chop(int n) 从字符串尾部删除_n_个字符。

如果_n_大于或等于 size() ,结果是一个空字符串;如果_n_为负值,相当于传入了0

例如:

如果想从字符串的首部删除字符,请使用 remove() 代替。

See also truncate() resize() remove() QStringRef::chop()

QString::chopped

[public plain  ]

QString chopped(int len) const 返回一个从左开始 size() -_len_的长度的字符串。

注意:如果_len_为负值或大于 size() ,则未定义该行为。

See also endsWith() left() right() mid() chop() truncate()

QString::clear

[public plain  ]

void clear() 清除字符串的内容并使其为 null。

See also resize() isNull()

QString::compare

[public plain static ]

int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs) 将_s1_和_s2_进行比较,如果_s1_和_s2_相等则返回0,如果s1大于s2则返回大于0,否则就返回小于0的整数。

如果_cs_是 Qt::CaseSensitive ,则比较区分大小写;否则比较不区分大小写。

大小写敏感比较完全基于字符的 Unicode 数值,速度非常快,但不是人们所期望的。考虑用 localeAwareCompare() 对用户可见的字符串进行排序。

See also operator==() operator<() operator>() Comparing Strings

QString::compare

[public plain  ]

int compare(const QString &other, Qt::CaseSensitivity cs) const 这个函数重载了 compare()

将该字符串与另一个字符串_other_进行比较,如果相等则返回0,如果大于另一个字符串则大于0,否则就返回小于0的整数。

和 compare(*this, other, cs)一样。

QString::compare

[public plain  ]

int compare(const QStringRef &ref, Qt::CaseSensitivity cs) const 这个函数重载了 compare()

将该字符串与引用字符串_ref_进行比较,如果相等则返回0,如果大于另一个字符串_ref_则大于0,否则就返回小于0的整数。

QString::compare

[public plain  ]

int compare(QLatin1String other, Qt::CaseSensitivity cs) const 这个函数重载了 compare()

和 compare(*this, other, cs)一样。

QString::compare

[public plain  ]

int compare(QStringView s, Qt::CaseSensitivity cs) const 这个函数重载了 compare()

通过设置_cs_参数,来决定是否大小写敏感,然后再和_s_进行比较

QString::compare

[public plain  ]

int compare(QChar ch, Qt::CaseSensitivity cs) const 这个函数重载了 compare()

通过设置_cs_参数,来决定是否大小写敏感,然后再和_ch_进行比较

QString::compare

[public plain static ]

int compare(const QString &s1, QLatin1String s2, Qt::CaseSensitivity cs) 这个函数重载了 compare()

通过设置_cs_参数,来决定是否大小写敏感,然后_s1_和_s2_进行比较

QString::compare

[public plain static ]

int compare(QLatin1String s1, const QString &s2, Qt::CaseSensitivity cs) 这个函数重载了 compare()

通过设置_cs_参数,来决定是否大小写敏感,然后_s1_和_s2_进行比较

QString::compare

[public plain static ]

int compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs) 这个函数重载了 compare()

QString::compare_helper

[private plain static ]

int compare_helper(const QChar *data1, int length1, const QChar *data2, int length2, Qt::CaseSensitivity cs)

QString::compare_helper

[private plain static ]

int compare_helper(const QChar *data1, int length1, QLatin1String s2, Qt::CaseSensitivity cs)

QString::compare_helper

[private plain static ]

int compare_helper(const QChar *data1, int length1, const char *data2, int length2, Qt::CaseSensitivity cs)

QString::constBegin

[public plain  ]

QString::const_iterator constBegin() const 返回一个指向字符串中第一个字符的 STL-style iterators

See also begin() constEnd()

QString::constData

[public plain  ]

const QChar * constData() const 返回一个指向 QString 中存储的数据的指针。这个指针可以用来访问组成字符串的字符。

请注意,只有在字符串没有被修改的情况下,指针才会保持有效。

注意:返回的字符串可能不是以‘\0‘结束的。使用 size() 来确定数组的长度。

See also data() operator fromRawData()

QString::constEnd

[public plain  ]

QString::const_iterator constEnd() const 返回指向列表中最后一个字符后的虚构字符的 STL-style iterators 式迭代器。

See also constBegin() end()

QString::contains

[public plain  ]

bool contains(const QString &str, Qt::CaseSensitivity cs) const 如果字符串中包含字符串_str_,返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

例如:

See also indexOf() count()

QString::contains

[public plain  ]

bool contains(QChar ch, Qt::CaseSensitivity cs) const 这个函数重载了 contains()

如果该字符串包含字符_ch_,则返回True;否则返回false

QString::contains

[public plain  ]

bool contains(const QStringRef &str, Qt::CaseSensitivity cs) const 如果这个字符串包含了字符串引用_str_,则返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also indexOf() count()

QString::contains

[public plain  ]

bool contains(QLatin1String str, Qt::CaseSensitivity cs) const 这个函数重载了 contains()

如果这个字符串包含 latin-1 字符串的出现,返回True;否则返回false

QString::contains

[public plain  ]

bool contains(QStringView str, Qt::CaseSensitivity cs) const 这个函数重载了 contains()

如果这个字符串中包含_str_,返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also indexOf() count()

QString::contains

[public plain  ]

bool contains(const QRegExp &rx) const 这个函数重载了 contains()

如果正则表达式_rx_在这个字符串中的某个地方匹配,则返回True;否则返回false

QString::contains

[public plain  ]

bool contains(QRegExp &rx) const 这个函数重载了 contains()

如果正则表达式_rx_在这个字符串中的某个地方匹配,则返回True;否则返回false

如果有匹配,_rx_正则表达式将包含匹配的捕获(参见 QRegExp::matchedLengthQRegExp::cap )。

QString::contains

[public plain  ]

bool contains(const QRegularExpression &re) const 这个函数重载了 contains()

如果正则表达式重新匹配到这个字符串的某个地方,则返回True;否则返回false

QString::contains

[public plain  ]

bool contains(const QRegularExpression &re, QRegularExpressionMatch *rmatch) const 这个函数重载了 contains()

如果正则表达式重新匹配到这个字符串的某个地方,则返回True;否则返回false

如果匹配成功,且_rmatch_不是nullptr,它将匹配结果写入_rmatch_指向的 QRegularExpressionMatch 对象中。

See also QRegularExpression::match()

QString::count

[public plain  ]

int count(const QString &str, Qt::CaseSensitivity cs) const 返回字符串在该字符串中出现的(潜在的重叠)次数。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also contains() indexOf()

QString::count

[public plain  ]

int count() const 这是一个重载函数。

size() 方法一样。

QString::count

[public plain  ]

int count(QChar ch, Qt::CaseSensitivity cs) const 这个函数重载了 count()

返回当前字符串中含有字符_ch_的个数。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also contains() indexOf()

QString::count

[public plain  ]

int count(const QStringRef &str, Qt::CaseSensitivity cs) const 这个函数重载了 count()

返回此字符串中字符串引用_str_的出现次数(可能重叠)。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also contains() indexOf()

QString::count

[public plain  ]

int count(const QRegExp &rx) const 这个函数重载了 count()

返回字符串中正则表达式_re_匹配到的次数。

这个函数计算重叠的匹配,所以在下面的例子中,有四个 "anna" 或 "ama" 的实例。

QString::count

[public plain  ]

int count(const QRegularExpression &re) const 这个函数重载了 count()

返回字符串中与正则表达式_re_重新匹配的次数。

由于历史原因,这个函数会计算重叠的匹配,所以在下面的例子中,有四个 "anna" 或 "ama" 的实例。

这种行为与使用 QRegularExpressionMatchIterator 简单地迭代字符串中的匹配项不同。

See also QRegularExpression::globalMatch()

QString::crbegin

[public plain  ]

QString::const_reverse_iterator crbegin() const 返回一个 STL-style iterators 反向迭代器,按反向顺序指向字符串中的第一个字符。

See also begin() rbegin() rend()

QString::crend

[public plain  ]

QString::const_reverse_iterator crend() const 返回一个 STL-style iterators 反向迭代器,以反向顺序指向字符串中最后一个字符。

See also end() rend() rbegin()

QString::data

[public plain  ]

QChar * data() 返回一个指向 QString 中存储的数据的指针。这个指针可以用来访问和修改组成字符串的字符。

constData()unicode() 不同,返回的数据总是以‘\0’结尾。

例如:

请注意,只有在字符串没有被其它方式修改的情况下,指针才会保持有效。对于只读访问, constData() 的速度更快,因为它不会导致深拷贝的发生。

See also constData() operator

QString::data

[public plain  ]

const QChar * data() const 这是一个重载函数。

注意:返回的字符串可能不是以‘\0‘结束的。使用 size() 来确定数组的长度。

See also fromRawData()

QString::data_ptr

[private plain  ]

QString::DataPtr & data_ptr()

QString::detach

[private plain  ]

void detach()

QString::end

[public plain  ]

QString::iterator end() 返回一个 STL-style iterators 迭代器,指向字符串中最后一个字符后的虚构字符。

See also begin() constEnd()

QString::end

[public plain  ]

QString::const_iterator end() const 这个函数重载了 end()

QString::endsWith

[public plain  ]

bool endsWith(const QString &s, Qt::CaseSensitivity cs) const 如果字符串以_s_结尾,返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also startsWith()

QString::endsWith

[public plain  ]

bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs) const 这个函数重载了 endsWith()

如果字符串以_s_结束,返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also startsWith()

QString::endsWith

[public plain  ]

bool endsWith(QStringView str, Qt::CaseSensitivity cs) const 这个函数重载了 endsWith()

如果字符串以变量_str_结束,则返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also startsWith()

QString::endsWith

[public plain  ]

bool endsWith(QLatin1String s, Qt::CaseSensitivity cs) const 这个函数重载了 endsWith()

QString::endsWith

[public plain  ]

bool endsWith(QChar c, Qt::CaseSensitivity cs) const 如果字符串以_c_结尾,返回True;否则返回false

这个函数重载了 endsWith()

QString::expand

[private plain  ]

void expand(int i)

QString::fill

[public plain  ]

QString & fill(QChar ch, int size) 将字符串中的每个字符设置为字符_ch_,如果_size_不是-1(默认值),则先将字符串长度调整为_size_。

例如:

See also resize()

QString::fromAscii

[public plain static ]

QString fromAscii(const char *str, int size) 返回一个用字符串_str_中的第一个_size_字符初始化的 QString

如果_size_为-1(默认),则取为 strlen(str)。

这个函数和 fromLatin1() 一样。

See also toAscii() fromLatin1() fromUtf8() fromLocal8Bit()

QString::fromAscii

[public plain static ]

QString fromAscii(const QByteArray &str) 这是一个重载函数。

返回一个用字符串_str_初始化的 QString

QString::fromAscii_helper

[private plain static ]

QString::Data * fromAscii_helper(const char *str, int size)

QString::fromCFString

[public plain static ]

QString fromCFString(CFStringRef string) 构造一个新的 QString ,包含 CFString 类型_string_的副本。

注意:此功能仅在 OS X 和 iOS 上可用。

QString::fromLatin1

[public plain static ]

QString fromLatin1(const char *str, int size) 返回一个 QString ,初始化为 Latin-1 字符串_str_的第一个_size_的字符

如果_size_为-1(默认),则取为 strlen(str)。

See also toLatin1() fromUtf8() fromLocal8Bit()

QString::fromLatin1

[public plain static ]

QString fromLatin1(const QByteArray &str) 这是一个重载函数。

返回一个初始化为 Latin-1 字符串_str_的 QString

QString::fromLatin1_helper

[private plain static ]

QString::Data * fromLatin1_helper(const char *str, int size)

QString::fromLocal8Bit

[public plain static ]

QString fromLocal8Bit(const char *str, int size) 返回一个用8位字符串_str_首部_size_大小的字符初始化后的 QString

如果_size_为-1(默认),则取为 strlen(str)。

QTextCodec::codecForLocale() 用于执行转换。

See also toLocal8Bit() fromLatin1() fromUtf8()

QString::fromLocal8Bit

[public plain static ]

QString fromLocal8Bit(const QByteArray &str) 这是一个重载函数。

返回一个用8位字符串_str_初始化的 QString

QString::fromLocal8Bit_helper

[private plain static ]

QString fromLocal8Bit_helper(const char *, int size)

QString::fromNSString

[public plain static ]

QString fromNSString(const NSString *string) 构造一个新的 QString ,包含 NSString 类型_string_的副本。

注:此功能仅在 OS X 和 iOS 上可用。

QString::fromRawData

[public plain static ]

QString fromRawData(const QChar *unicode, int size) 使用数组_unicode_中首个_size_的 Unicode 字符构造一个 QString 。_unicode_中的数据不会被复制。调用者必须保证只要 QString (或其未修改的副本)存在,_unicode_就不会被删除或修改。

任何试图修改 QString 或其副本的行为都会导致它创建一个数据的深度副本,确保原始数据不被修改。

下面是一个例子,说明我们如何对内存中的原始数据使用 QRegularExpression ,而不需要将数据复制到一个 QString 中。

警告:创建的字符串not以'\0'结束,除非原始数据在位置_size_包含一个'\0'字符。这意味着 unicode()not返回一个'\0'结尾的字符串(尽管 utf16() 可以,但要以复制原始数据为代价)。

See also fromUtf16() setRawData()

QString::fromStdString

[public plain static ]

QString fromStdString(const std::string &str) 返回_str_字符串的副本。使用 fromUtf8() 函数将给定的字符串转换为 Unicode。

See also fromLatin1() fromLocal8Bit() fromUtf8() QByteArray::fromStdString()

QString::fromStdU16String

[public plain static ]

QString fromStdU16String(const std::u16string &str) 返回_str_字符串的副本。给定的字符串假定为 UTF-16 编码。

See also fromUtf16() fromStdWString() fromStdU32String()

QString::fromStdU32String

[public plain static ]

QString fromStdU32String(const std::u32string &str) 返回_str_字符串的副本。给定的字符串假定为 UCS-4 编码。

See also fromUcs4() fromStdWString() fromStdU16String()

QString::fromStdWString

[public plain static ]

QString fromStdWString(const std::wstring &str) 返回_str_字符串的副本。如果 wchar_t 的大小为2字节,则假定字符串的编码为 UTF-16(例如在 Windows 下),如果 wchar_t 的大小为4字节,则假定字符串的编码为 UCS-4(大多数 Unix 系统)。

See also fromUtf16() fromLatin1() fromLocal8Bit() fromUtf8() fromUcs4() fromStdU16String() fromStdU32String()

QString::fromUcs4

[public plain static ]

QString fromUcs4(const uint *unicode, int size) 返回一个 QString ,初始化为 Unicode 字符串_unicode_(ISO-10646-UCS-4编码)的首个_size_字符。

如果_size_为-1(默认值),_unicode_必须以‘\0’为结束。

See also toUcs4() fromUtf16() utf16() setUtf16() fromWCharArray() fromStdU32String()

QString::fromUcs4

[public plain static ]

QString fromUcs4(const char32_t *str, int size) 返回一个以 Unicode 字符串_str_(ISO-10646-UCS-4 编码)的首个_size_字符初始化的 QString

如果_size_为-1(默认),_str_必须以‘\0’结束。

See also toUcs4() fromUtf16() utf16() setUtf16() fromWCharArray() fromStdU32String()

QString::fromUtf16

[public plain static ]

QString fromUtf16(const ushort *unicode, int size) 返回一个 QString ,初始化为 Unicode 字符串_unicode_(ISO-10646-UTF-16 编码)的首个_size_字符。

如果_size_为-1(默认值),_unicode_必须以‘\0’为结束。

该函数检查字节顺序标记(BOM)。如果没有,则假定主机字节顺序。

这个函数与其它 Unicode 转换相比,速度很慢。如果可能的话,使用 QString (const QChar *, int)或 QString (const QChar *)。

QString 对 Unicode 数据进行深度复制。

See also utf16() setUtf16() fromStdU16String()

QString::fromUtf16

[public plain static ]

QString fromUtf16(const char16_t *str, int size) 返回一个用 Unicode 字符串_str_(ISO-10646-UTF-16 编码)的首个_size_字符初始化的 QString

如果_size_为-1(默认),_str_必须以 ‘\0’结束。

该函数检查字节顺序标记(BOM)。如果没有,则假定主机字节顺序。

这个函数与其它 Unicode 转换相比,速度很慢。如果可能的话,使用 QString (const QChar *, int)或 QString (const QChar *)。

QString 对 Unicode 数据进行深度复制。

See also utf16() setUtf16() fromStdU16String()

QString::fromUtf8

[public plain static ]

QString fromUtf8(const char *str, int size) 返回一个 UTF-8 格式的字符串_str_,以首个字节_size_初始化的 QString

如果_size_为-1(默认),则取为 strlen(str)。

UTF-8 是一种 Unicode 编解码器,可以表示 Unicode 字符串中的所有字符,比如 QString 。然而,UTF-8 有可能出现无效的序列,如果发现任何这样的序列,它们将被一个或多个 "替换字符 "替换,或者被抑制。这些包括非 Unicode 序列、非字符、过长的序列或编码到 UTF-8 的代用码点。

只要输入的数据中所有 UTF-8 字符都被终止,该函数就可以用来递增处理输入的数据。字符串末尾的任何未终止的字符将被替换或抑制。如果要进行有状态的解码,请使用 QTextDecoder

See also toUtf8() fromLatin1() fromLocal8Bit()

QString::fromUtf8

[public plain static ]

QString fromUtf8(const QByteArray &str) 这是一个重载函数。

返回一个用 UTF-8 字符串_str_初始化的 QString

QString::fromUtf8_helper

[private plain static ]

QString fromUtf8_helper(const char *str, int size)

QString::fromWCharArray

[public plain static ]

QString fromWCharArray(const wchar_t *string, int size) 返回_string_的副本,_string_的编码取决于 wchar 的大小,如果 wchar 是4个字节,则解释为 UCS-4,如果 wchar 是2个字节,则解释为 UTF-16。

如果_size_为-1(默认值),则_string_必须以‘\0’结尾。

See also fromUtf16() fromLatin1() fromLocal8Bit() fromUtf8() fromUcs4() fromStdWString()

QString::front

[public plain  ]

QChar front() const 返回字符串中的第一个字符。与at(0)相同。

此功能是为了兼容 STL 而提供的。

警告:在一个空字符串上调用此函数会构成未定义的行为。

See also back() at() operator

QString::front

[public plain  ]

QCharRef front() 返回字符串中第一个字符的引用。与operator[](0)相同。

此功能是为了兼容 STL 而提供的。

警告:在一个空字符串上调用此函数会构成未定义的行为。

See also back() at() operator

QString::indexOf

[public plain  ]

int indexOf(QLatin1String str, int from, Qt::CaseSensitivity cs) const 返回字符串_str_在该字符串中第一次出现的索引位置,从索引位置_from_向前搜索。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

例如:

如果_from_是-1,则从最后一个字符开始搜索;如果是-2,则从下一个到最后一个字符开始搜索,以此类推。

See also lastIndexOf() contains() count()

QString::indexOf

[public plain  ]

int indexOf(QChar ch, int from, Qt::CaseSensitivity cs) const 这个函数重载了 indexOf()

返回字符串中第一次出现的字符_ch_的索引位置,从索引位置_from_向前搜索。如果找不到_ch_,则返回-1。

QString::indexOf

[public plain  ]

int indexOf(const QString &str, int from, Qt::CaseSensitivity cs) const 返回字符串_str_在该字符串中第一次出现的索引位置,从索引位置_from_向前搜索。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

例如:

如果_from_是-1,则从最后一个字符开始搜索;如果是-2,则从下一个到最后一个字符开始搜索,以此类推。

See also lastIndexOf() contains() count()

QString::indexOf

[public plain  ]

int indexOf(const QStringRef &str, int from, Qt::CaseSensitivity cs) const 这个函数重载了 indexOf()

返回字符串中第一次出现的字符串引用_str_的索引位置,从索引位置_from_向前搜索。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

QString::indexOf

[public plain  ]

int indexOf(QStringView str, int from, Qt::CaseSensitivity cs) const 这个函数重载了 indexOf()

返回字符串中第一个出现的字符串视图_str_的索引位置,从索引位置_from_向前搜索。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

如果_from_是-1,则从最后一个字符开始搜索;如果是-2,则从下一个到最后一个字符开始搜索,以此类推。

See also QStringView::indexOf() lastIndexOf() contains() count()

QString::indexOf

[public plain  ]

int indexOf(const QRegExp &rx, int from) const 这个函数重载了 indexOf()

返回正则表达式_rx_在字符串中第一次匹配的索引位置,从索引位置_from_向前搜索。如果没有匹配到任何地方,则返回-1。

例如:

QString::indexOf

[public plain  ]

int indexOf(QRegExp &rx, int from) const 这个函数重载了 indexOf()

返回正则表达式_rx_在字符串中第一次匹配的索引位置,从索引位置_from_向前搜索。如果没有匹配到任何地方,则返回-1。

如果有匹配,正则表达式_rx_将包含匹配的捕获(参见 QRegExp::matchedLengthQRegExp::cap )。

例如:

QString::indexOf

[public plain  ]

int indexOf(const QRegularExpression &re, int from) const 这个函数重载了 indexOf()

返回正则表达式_re_在字符串中第一次匹配的索引位置,从索引位置_from_向前搜索。如果没有匹配到任何地方,则返回-1。

例如:

QString::indexOf

[public plain  ]

int indexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const 这是一个重载函数。

返回正则表达式_re_在字符串中第一次匹配的索引位置,从索引位置_from_向前搜索。如果没有匹配到任何地方,则返回-1。

如果匹配成功,且_rmatch_不是nullptr,它将匹配结果写入_rmatch_指向的 QRegularExpressionMatch 对象中。

例如:

QString::insert

[public plain  ]

QString & insert(int position, const QString &str) 在给定的索引位置插入字符串_str_,并返回对该字符串的引用。

例如:

如果_position_大于 size() ,则首优先使用扩展数组。

See also append() prepend() replace() remove()

QString::insert

[public plain  ]

QString & insert(int position, QChar ch) 这个函数重载了 insert()

在字符串中给定的索引_position_插入_ch_。

QString::insert

[public plain  ]

QString & insert(int position, const QChar *unicode, int size) 这个函数重载了 insert()

在字符串中给定的索引_position_插入 QChar 数组_unicode_的首个_size_字符。

QString::insert

[public plain  ]

QString & insert(int position, const QStringRef &str) 这个函数重载了 insert()

在索引_position_插入字符串引用_str_,并返回这个字符串的引用。

如果_position_大于 size() ,则首优先使用扩展数组。

QString::insert

[public plain  ]

QString & insert(int position, QStringView str) 这个函数重载了 insert()

在索引_position_插入字符串引用_str_,并返回这个字符串的引用。

如果_position_大于 size() ,则首优先使用扩展数组。

注意:5.15.2中增加了这个方法,以方便在 Qt 5.15 和 Qt 6 之间代码移植。

QString::insert

[public plain  ]

QString & insert(int position, QLatin1String str) 这个函数重载了 insert()

在_position_位置插入 Latin-1 字符串_str_。

QString::insert

[public plain  ]

QString & insert(int position, const char *str) 这个函数重载了 insert()

在索引_position_插入 C 字符串_str_,并返回对该字符串的引用。

如果_position_大于 size() ,则首优先使用扩展数组。

当定义了QT_NO_CAST_FROM_ASCII时,此函数不可用。

See also QT_NO_CAST_FROM_ASCII

QString::insert

[public plain  ]

QString & insert(int position, const QByteArray &str) 这个函数重载了 insert()

在索引_position_插入字节数组_str_,并返回对该字符串的引用。

如果_position_大于 size() ,则首优先使用扩展数组。

当定义了QT_NO_CAST_FROM_ASCII时,此函数不可用。

See also QT_NO_CAST_FROM_ASCII

QString::isDetached

[private plain  ]

bool isDetached() const

QString::isEmpty

[public plain  ]

bool isEmpty() const 如果字符串中没有字符,返回True;否则返回false

例如:

See also size()

QString::isLower

[public plain  ]

bool isLower() const 如果字符串都是小写,即与其 toLower() 转换相同,则返回True

请注意,这并不意味着字符串中不包含大写字母(有些大写字母没有小写转换,它们被 toLower() 保持不变)。更多信息,请参考 Unicode 标准,3.13节。

See also QChar::toLower() isUpper()

QString::isNull

[public plain  ]

bool isNull() const 如果该字符串为 null,返回True;否则返回false

例如:

由于历史原因,Qt 对 null 字符串和 empty 字符串进行了区分。对于大多数应用程序来说,重要的是一个字符串是否包含任何数据,这可以通过 isEmpty() 函数来确定。

See also isEmpty()

QString::isRightToLeft

[public plain  ]

bool isRightToLeft() const 如果从右到左读取字符串,返回True

See also QStringRef::isRightToLeft()

QString::isSharedWith

[private plain  ]

bool isSharedWith(const QString &other) const

QString::isSimpleText

[private plain  ]

bool isSimpleText() const

QString::isUpper

[public plain  ]

bool isUpper() const 如果字符串是大写的,即与它的 toUpper() 转换相同,返回True

请注意,这并不意味着字符串中不包含小写字母(一些小写字母没有大写转换,它们被 toUpper() 保持不变)。更多信息,请参考 Unicode 标准,3.13节。

See also QChar::toUpper() isLower()

QString::isValidUtf16

[public plain  ]

bool isValidUtf16() const 如果字符串包含有效的 UTF-16 编码数据,则返回True,否则返回false

请注意,这个函数并不对数据进行任何特殊的验证;它只是检查数据是否能从 UTF-16 中成功解码。假定数据为按主机字节顺序排列;BOM 的存在毫无意义。

See also QStringView::isValidUtf16()

QString::lastIndexOf

[public plain  ]

int lastIndexOf(const QString &str, int from, Qt::CaseSensitivity cs) const 返回字符串_str_最后出现的索引位置,从索引位置_from_向后搜索。如果_from_是-1(默认),则从最后一个字符开始搜索;如果_from_是-2,则从下一个到最后一个字符开始搜索,依此类推。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

例如:

See also indexOf() contains() count()

QString::lastIndexOf

[public plain  ]

int lastIndexOf(QChar ch, int from, Qt::CaseSensitivity cs) const 这个函数重载了 lastIndexOf()

返回字符_ch_最后出现的索引位置,从_from_位置向后搜索。

QString::lastIndexOf

[public plain  ]

int lastIndexOf(QLatin1String str, int from, Qt::CaseSensitivity cs) const 这个函数重载了 lastIndexOf()

返回字符串_str_最后出现的索引位置,从索引位置_from_向后搜索。如果_from_是-1(默认),则从最后一个字符开始搜索;如果_from_是-2,则从下一个到最后一个字符开始搜索,依此类推。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

例如:

See also indexOf() contains() count()

QString::lastIndexOf

[public plain  ]

int lastIndexOf(const QStringRef &str, int from, Qt::CaseSensitivity cs) const 这个函数重载了 lastIndexOf()

返回字符串中最后出现的字符串引用_str_的索引位置,从索引位置_from_向后搜索。如果_from_是-1(默认),则从最后一个字符开始搜索;如果_from_是-2,则从下一个到最后一个字符开始搜索,依此类推。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also indexOf() contains() count()

QString::lastIndexOf

[public plain  ]

int lastIndexOf(QStringView str, int from, Qt::CaseSensitivity cs) const 这个函数重载了 lastIndexOf()

返回字符串中最后出现的视图_str_的索引位置,从索引位置_from_向后搜索。如果_from_是-1(默认),则从最后一个字符开始搜索;如果_from_是-2,则从下一个到最后一个字符开始搜索,依此类推。如果没有找到_str_,返回-1。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also indexOf() contains() count()

QString::lastIndexOf

[public plain  ]

int lastIndexOf(const QRegExp &rx, int from) const 这个函数重载了 lastIndexOf()

返回字符串中正则表达式_rx_最后匹配的索引位置,从索引位置_from_向后搜索。如果_rx_没有匹配到任何地方,则返回-1。

例如:

QString::lastIndexOf

[public plain  ]

int lastIndexOf(QRegExp &rx, int from) const 这个函数重载了 lastIndexOf()

返回字符串中正则表达式_rx_最后匹配的索引位置,从索引位置_from_向后搜索。如果_rx_没有匹配到任何地方,则返回-1。

如果有匹配,_rx_正则表达式将包含匹配的捕获(参见 QRegExp::matchedLengthQRegExp::cap )。

例如:

QString::lastIndexOf

[public plain  ]

int lastIndexOf(const QRegularExpression &re, int from) const 这个函数重载了 lastIndexOf()

返回正则表达式_re_在字符串中最后一次匹配的索引位置,从索引位置_from_之前开始。如果_re_没有匹配到任何地方,则返回-1。

例如:

QString::lastIndexOf

[public plain  ]

int lastIndexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const 这是一个重载函数。

返回正则表达式_re_在字符串中最后一次匹配的索引位置,从索引位置_from_之前开始。如果_re_没有匹配到任何地方,则返回-1。

如果匹配成功,且_rmatch_不是nullptr,它将匹配结果写入_rmatch_指向的 QRegularExpressionMatch 对象中。

例如:

QString::left

[public plain  ]

QString left(int n) const 返回一个包含字符串最左边_n_个字符的子串。

如果_n_大于或等于 size() ,或者小于0,则返回整个字符串。

See also right() mid() startsWith() chopped() chop() truncate()

QString::leftJustified

[public plain  ]

QString leftJustified(int width, QChar fill, bool truncate) const 返回一个大小为_width_的字符串,其中包含了这个由填充字符_fill_的字符串。

如果_truncate_为false,并且字符串的 size() 大于_width_,那么返回的字符串就是字符串的副本。

如果_truncate_为True,且字符串的 size() 大于_width_,那么字符串副本中位置_width_之后的任何字符都会被删除,并返回副本。

See also rightJustified()

QString::leftRef

[public plain  ]

QStringRef leftRef(int n) const 返回字符串中最左边的_n_个字符的子串引用。

如果_n_大于等于 size() ,或者小于0,则返回整个字符串的引用。

See also left() rightRef() midRef() startsWith()

QString::length

[public plain  ]

int length() const 返回此字符串中的字符数。相当于 size()

See also resize()

QString::localeAwareCompare

[public plain static ]

int localeAwareCompare(const QString &s1, const QString &s2) 将_s1_和_s2_进行比较,如果_s1_和_s2_相等则返回0,如果_s1_大于_s2_则返回大于0,否则就返回小于0的整数。

比较是以本地和平台相关的方式进行的。使用该函数向用户展示排序的字符串列表。

See also compare() QLocale Comparing Strings

QString::localeAwareCompare

[public plain  ]

int localeAwareCompare(const QString &other) const 这个函数重载了 localeAwareCompare()

将此字符串与_other_字符串进行比较,如果相等则返回0,如果大于则返回大于0,否则就返回小于0的整数。

比较是以本地和平台相关的方式进行的。使用该函数向用户展示排序的字符串列表。

localeAwareCompare(*this, other)一样。

See also Comparing Strings

QString::localeAwareCompare

[public plain  ]

int localeAwareCompare(const QStringRef &other) const 这个函数重载了 localeAwareCompare()

将此字符串与_other_字符串进行比较,如果相等则返回0,如果大于则返回大于0,否则就返回小于0的整数。

比较是以本地和平台相关的方式进行的。使用该函数向用户展示排序的字符串列表。

localeAwareCompare(*this, other)一样。

See also Comparing Strings

QString::localeAwareCompare

[public plain static ]

int localeAwareCompare(const QString &s1, const QStringRef &s2) 这个函数重载了 localeAwareCompare()

将_s1_和_s2_进行比较,如果_s1_和_s2_相等则返回0,如果_s1_大于_s2_则返回大于0,否则就返回小于0的整数。

比较是以本地和平台相关的方式进行的。使用该函数向用户展示排序的字符串列表。

See also Comparing Strings

QString::localeAwareCompare_helper

[private plain static ]

int localeAwareCompare_helper(const QChar *data1, int length1, const QChar *data2, int length2)

QString::mid

[public plain  ]

QString mid(int position, int n) const 返回一个包含该字符串的_n_个字符的字符串,从指定的_position_索引开始。

如果_position_索引超过字符串的长度,返回一个空字符串。如果从_position_开始的字符串中可用的字符少于_n_个,或者如果_n_为-1(默认值),函数将返回从开始的所有可用字符。

例如:

See also left() right() chopped() chop() truncate()

QString::midRef

[public plain  ]

QStringRef midRef(int position, int n) const 返回从_position_开始的_n_个字符的子串引用。

如果_position_超过了字符串的长度,将返回一个空引用。

如果字符串中可用的字符少于_n_个,从给定的_position_开始,或者如果_n_是-1(默认),函数将返回_position_开始的所有字符。

例如:

See also mid() leftRef() rightRef()

QString::multiArg

[private plain  ]

QString multiArg(int numArgs, const QString **args) const

QString::normalized

[public plain  ]

QString normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version) const 根据给定的 Unicode 标准_version_,以给定的 Unicode 规范化_mode_返回字符串。

QString::number

[public plain static ]

QString number(long n, int base) 根据指定的_base_,返回数字_n_的等价字符串。

base 默认为10,必须在2和36之间。对于10以外的 base,_n_将作为无符号整数处理。

格式化总是使用 QLocale::C ,即 English/UnitedStates。要获得一个数字的本地化字符串表示,使用 QLocale::toString() 和适当的 locale。

See also setNum()

QString::number

[public plain static ]

QString number(int n, int base) 这是一个重载函数。

QString::number

[public plain static ]

QString number(uint n, int base) 这是一个重载函数。

QString::number

[public plain static ]

QString number(ulong n, int base) 这是一个重载函数。

QString::number

[public plain static ]

QString number(qlonglong n, int base) 这是一个重载函数。

QString::number

[public plain static ]

QString number(qulonglong n, int base) 这是一个重载函数。

QString::number

[public plain static ]

QString number(double n, char format, int precision) 根据指定的_格式_和_精度_进行格式化,返回数字_n_的等价字符串。详情请参见 Argument Formats

QLocale::toString() 不同,这个函数不遵循用户的 locale 设置。

See also setNum() QLocale::toString()

QString::operator!=

[public plain  ]

bool operator!=(QLatin1String other) const 如果该字符串不等于参数_other_,则返回True,否则返回false

这是一个重载函数。

QString::operator!=

[public plain  ]

bool operator!=(const char *other) const 这个函数重载了 operator!=()

_other_使用 fromUtf8() 函数转换为 QString

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator!=

[public plain  ]

bool operator!=(const QByteArray &other) const 这个函数重载了 operator!=()

_other_使用 fromUtf8() 函数转换为 QString 。如果在字节数组中嵌入了任何 NUL 字符(‘\0’),它们将被包含在转换中。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

暂无该属性

[public plain  ]

const QString operator+(const QString &s1, const QString &s2) 返回一个字符串,它是_s1_和_s2_连接的结果。

暂无该属性

[private plain  ]

const QString operator+(const QString &s1, QChar s2)

暂无该属性

[private plain  ]

const QString operator+(QChar s1, const QString &s2)

暂无该属性

[public plain  ]

const QString operator+(const QString &s1, const char *s2) 返回一个字符串,它是_s1_和_s2_连接的结果(_s2_使用 QString::fromUtf8() 函数转换为Unicode)。

See also QString::fromUtf8()

暂无该属性

[public plain  ]

const QString operator+(const char *s1, const QString &s2) 返回一个字符串,它是_s1_和_s2_连接的结果(_s1_使用 QString::fromUtf8() 函数转换为 Unicode)。

See also QString::fromUtf8()

暂无该属性

[public plain  ]

const QString operator+(char ch, const QString &s) 返回一个字符串,它是字符_ch_和字符串_s_连接的结果。

暂无该属性

[public plain  ]

const QString operator+(const QString &s, char ch) 返回一个字符串,它是字符串_s_和字符_ch_连接的结果。

暂无该属性

[private plain  ]

const QString operator+(const QByteArray &ba, const QString &s)

暂无该属性

[private plain  ]

const QString operator+(const QString &s, const QByteArray &ba)

暂无该属性

[private plain  ]

QString operator+(const QString &s1, const QStringRef &s2)

暂无该属性

[private plain  ]

QString operator+(const QStringRef &s1, const QString &s2)

暂无该属性

[private plain  ]

QString operator+(const QStringRef &s1, QLatin1String s2)

暂无该属性

[private plain  ]

QString operator+(QLatin1String s1, const QStringRef &s2)

暂无该属性

[private plain  ]

QString operator+(const QStringRef &s1, const QStringRef &s2)

暂无该属性

[private plain  ]

QString operator+(const QStringRef &s1, QChar s2)

暂无该属性

[private plain  ]

QString operator+(QChar s1, const QStringRef &s2)

暂无该属性

[private plain  ]

QList::iterator operator+(QList::iterator::difference_type j, QList::iterator k)

暂无该属性

[private plain  ]

QList::const_iterator operator+(QList::const_iterator::difference_type j, QList::const_iterator k)

暂无该属性

[private plain  ]

QMap::iterator operator+(int j, QMap::iterator k)

暂无该属性

[private plain  ]

QMap::const_iterator operator+(int j, QMap::const_iterator k)

暂无该属性

[private plain  ]

QHash::iterator operator+(int j, QHash::iterator k)

暂无该属性

[private plain  ]

QHash::const_iterator operator+(int j, QHash::const_iterator k)

暂无该属性

[private plain  ]

QSequentialIterable::const_iterator operator+(int j, QSequentialIterable::const_iterator k)

暂无该属性

[private plain  ]

QAssociativeIterable::const_iterator operator+(int j, QAssociativeIterable::const_iterator k)

暂无该属性

[private plain  ]

QSet::iterator operator+(int j, QSet::iterator k)

暂无该属性

[private plain  ]

QSet::const_iterator operator+(int j, QSet::const_iterator k)

暂无该属性

[private plain  ]

qfloat16 operator+(qfloat16 a, qfloat16 b)

暂无该属性

[private plain  ]

long double operator+(qfloat16 lhs, long double rhs)

暂无该属性

[private plain  ]

long double operator+(long double lhs, qfloat16 rhs)

暂无该属性

[private plain  ]

double operator+(qfloat16 lhs, double rhs)

暂无该属性

[private plain  ]

double operator+(double lhs, qfloat16 rhs)

暂无该属性

[private plain  ]

float operator+(qfloat16 lhs, float rhs)

暂无该属性

[private plain  ]

float operator+(float lhs, qfloat16 rhs)

暂无该属性

[private plain  ]

double operator+(qfloat16 lhs, int rhs)

暂无该属性

[private plain  ]

double operator+(int lhs, qfloat16 rhs)

暂无该属性

[public plain  ]

QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs) 返回一个 QDeadlineTimer 对象,它的截止日期比_dt_中存储的截止日期晚几毫秒,如果_dt_被设置为永不过期,这个函数返回一个不会过期的 QDeadlineTimer 对象。

要添加精度大于1毫秒的时间,使用 addNSecs()

暂无该属性

[public plain  ]

QDeadlineTimer operator+(qint64 msecs, QDeadlineTimer dt) 返回一个 QDeadlineTimer 对象,它的截止日期比_dt_中存储的截止日期晚几毫秒,如果_dt_被设置为永不过期,这个函数返回一个不会过期的 QDeadlineTimer 对象。

要添加精度大于1毫秒的时间,使用 addNSecs()

暂无该属性

[private plain  ]

QDeadlineTimer operator+(QDeadlineTimer dt, std::chrono::duration<Rep, Period> value)

暂无该属性

[private plain  ]

QDeadlineTimer operator+(std::chrono::duration<Rep, Period> value, QDeadlineTimer dt)

暂无该属性

[public plain  ]

const QPoint operator+(const QPoint &p1, const QPoint &p2) 返回一个 QPoint 对象,它是给定点_p1_和_p2_的和;每个组件都是单独添加的。

See also QPoint::operator+=()

暂无该属性

[public plain  ]

const QPoint operator+(const QPoint &point) 返回未修改的_point_。

暂无该属性

[public plain  ]

const QPointF operator+(const QPointF &p1, const QPointF &p2) 返回一个 QPointF 对象,该对象是给定点_p1_和_p2_之和;每个组件都是单独添加的。

See also QPointF::operator+=()

暂无该属性

[public plain  ]

const QPointF operator+(const QPointF &point) 返回未修改的_point_。

暂无该属性

[private plain  ]

QFuture::const_iterator operator+(int j, QFuture::const_iterator k)

暂无该属性

[private plain  ]

QLinkedList::iterator operator+(int j, QLinkedList::iterator k)

暂无该属性

[private plain  ]

QLinkedList::const_iterator operator+(int j, QLinkedList::const_iterator k)

暂无该属性

[public plain  ]

QMargins operator+(const QMargins &m1, const QMargins &m2) 返回一个 QMargins 对象,该对象是给定的 margins 之和,即_m1_和_m2_;每个组件都是单独添加的。

See also QMargins::operator+=() QMargins::operator-=()

暂无该属性

[public plain  ]

QMargins operator+(const QMargins &lhs, int rhs) 返回一个_lhs_和_rhs_相加的 QMargins 对象。

See also QMargins::operator+=() QMargins::operator-=()

暂无该属性

[public plain  ]

QMargins operator+(int lhs, const QMargins &rhs) 返回一个_lhs_和_rhs_相加的 QMargins 对象。

See also QMargins::operator+=() QMargins::operator-=()

暂无该属性

[public plain  ]

QMargins operator+(const QMargins &margins) 返回一个和_margins_相加的 QMargin 对象。

暂无该属性

[public plain  ]

QMarginsF operator+(const QMarginsF &lhs, const QMarginsF &rhs) 返回一个由_lhs_和_rhs_的相加 QMarginsF 对象。

See also QMarginsF::operator+=() QMarginsF::operator-=()

暂无该属性

[public plain  ]

QMarginsF operator+(const QMarginsF &lhs, qreal rhs) 返回由_rhs_和_lhs_相加的 QMarginsF 对象。

See also QMarginsF::operator+=() QMarginsF::operator-=()

暂无该属性

[public plain  ]

QMarginsF operator+(qreal lhs, const QMarginsF &rhs) 返回由_lhs_和_rhs_相加的 QMarginsF 对象。

See also QMarginsF::operator+=() QMarginsF::operator-=()

暂无该属性

[public plain  ]

QMarginsF operator+(const QMarginsF &margins) 返回一个和_margins_相加的 QMargin 对象。

暂无该属性

[public plain  ]

const QSize operator+(const QSize &s1, const QSize &s2) 返回_s1_和_s2_的总和,每个组件都是单独添加的。

暂无该属性

[public plain  ]

const QSizeF operator+(const QSizeF &s1, const QSizeF &s2) 返回_s1_和_s2_的总和,每个组件都是单独添加的。

暂无该属性

[public plain  ]

QRect operator+(const QRect &rectangle, const QMargins &margins) 返回和_margins_相加的_rectangle_。

暂无该属性

[public plain  ]

QRect operator+(const QMargins &margins, const QRect &rectangle) 这是一个重载函数。

返回和_margins_相加的_rectangle_。

暂无该属性

[public plain  ]

QRectF operator+(const QRectF &lhs, const QMarginsF &rhs) 返回和_rhs_边距相加的_lhs_矩形。

暂无该属性

[public plain  ]

QRectF operator+(const QMarginsF &lhs, const QRectF &rhs) 这是一个重载函数。

返回和_rhs_边距相加的_lhs_矩形。

暂无该属性

[private plain  ]

timespec operator+(const timespec &t1, const timespec &t2)

QString::operator+=

[private plain  ]

QString & operator+=(QChar::SpecialCharacter c)

QString::operator+=

[public plain  ]

QString & operator+=(QChar ch) 这是一个重载函数。

将字符_ch_添加到字符串中。

QString::operator+=

[public plain  ]

QString & operator+=(const QString &other) 将字符串_other_附加到这个字符串的末尾,并返回对这个字符串的引用。

例如:

这个操作通常是非常快的(恒定时间),因为 QString 在字符串数据的末尾预分配了额外的空间,所以它可以在每次不重新分配整个字符串的情况下增长。

See also append() prepend()

QString::operator+=

[public plain  ]

QString & operator+=(const QStringRef &str) 这个函数重载了 operator+=()

将_str_引用的字符串部分追加到这个字符串上。

QString::operator+=

[public plain  ]

QString & operator+=(QLatin1String str) 这个函数重载了 operator+=()

将 Latin-1 字符串_str_追加到这个字符串上。

QString::operator+=

[public plain  ]

QString & operator+=(QStringView str) 这个函数重载了 operator+=()

将_str_引用的字符串部分追加到这个字符串上。

注意:5.15.2中增加了这个方法,以方便在 Qt 5.15 和 Qt 6 之间代码移植。

QString::operator+=

[public plain  ]

QString & operator+=(const char *str) 这个函数重载了 operator+=()

将字符串_str_附加到这个字符串上。const char* 使用 fromUtf8() 函数转换为 Unicode。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个函数。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator+=

[public plain  ]

QString & operator+=(const QByteArray &ba) 这个函数重载了 operator+=()

将字节数组_ba_添加到这个字符串中。字节数组使用 fromUtf8() 函数转换为 Unicode。如果任何 NUL字符(‘\0’)被嵌入到ba字节数组中,它们将被包含在转换过程中。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个函数。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator+=

[public plain  ]

QString & operator+=(char ch) 这个函数重载了 operator+=()

将字符_ch_添加到这个字符串中。需要注意的是,这个字符是通过 fromLatin1() 函数转换为 Unicode 的,与其它操作 UTF-8 数据的8位函数不同。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个函数。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator<

[public plain  ]

bool operator<(QLatin1String other) const 这是一个重载函数。

如果这个字符串小于名为_other_的参数字符串,则返回True,否则返回false

QString::operator<

[public plain  ]

bool operator<(const char *other) const 如果这个字符串在词法上小于字符串_other_,则返回True,否则返回false

这个函数重载了 operator<()

_other_使用 fromUtf8() 函数转换为 QString

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator<

[public plain  ]

bool operator<(const QByteArray &other) const 这个函数重载了 operator<()

_other_使用 fromUtf8() 函数转换为 QString 。如果在字节数组中嵌入了任何 NUL 字符(‘\0’),它们将被包含在转换中。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QString &string) 将_string_写入流_stream_中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QRegExp &regExp) 将正则表达式_regExp_写入流_out_中。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QRegExp &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QObject *)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QVariant &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &s, const QVariant &p) 将_p_写入流_s_中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &s, const QVariant::Type p) 将_p_写入流_s_中。

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QVariant::Type )

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QModelIndex &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QPersistentModelIndex &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QBitArray &ba) 将_ba_写入流_out_中。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QBitArray &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, QIODevice::OpenMode modes)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QLocale &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QLocale &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QDate &date) 将_date_写入流_out_中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QTime &time) 将_time_写入流_out_中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QDateTime &dateTime) 将_dateTime_写入流_out_中。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QDateTime &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QDate &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QTime &)

暂无该属性

[private plain  ]

QTextStream & operator<<(QTextStream &s, QTextStreamFunction f)

暂无该属性

[private plain  ]

QTextStream & operator<<(QTextStream &s, QTextStreamManipulator m)

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QList &list) 将_list_的内容写到_debug_中。但是T需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QVector &vec) 将_vec_的内容写入_debug_。但是T需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const std::vector<T, Alloc> &vec) 将 vector 类型_vec_的内容写入_debug_。但是T需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const std::list<T, Alloc> &vec) 将 list_vec_的内容写到_debug_中。但是T需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const std::map<Key, T, Compare, Alloc> &map) 将_map_的内容写到_debug_中。但是KeyT都需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const std::multimap<Key, T, Compare, Alloc> &map) 将_map_的内容写到_debug_中。但是KeyT都需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QMap<Key, T> &map) 将_map_的内容写到_debug_中。但是KeyT都需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QHash<Key, T> &hash) 将_hash_的内容写入_debug_。但是KeyT都需要支持流式传输到 QDebug

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair) 将_pair_的内容写入_debug_。但是T1T2都需要支持流式传输到 QDebug

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const std::pair<T1, T2> &pair)

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QSet &set) 将_set_的内容写入_debug_。但是T需要支持流到 QDebug

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const QContiguousCache &cache)

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QSharedPointer &ptr) 将_ptr_跟踪的指针写入 debug 对象_debug_中,用于调试。

See also Debugging Techniques

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QFlags &flags) 将写入中。

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , QCborSimpleType st)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , QCborKnownTags tg)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , QCborTag tg)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &ds, QCborSimpleType st)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QRegularExpression &re) 将正则表达式_re_写入到流_out_中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QRegularExpression &re) 将正则表达式_re_写入 debug 对象_debug_中,用于调试。

See also Debugging Techniques

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, QRegularExpression::PatternOptions patternOptions) 将模式选项_patternOptions_写入 debug 对象_debug_中,用于调试。

See also Debugging Techniques

暂无该属性

[public plain  ]

QDebug operator<<(QDebug debug, const QRegularExpressionMatch &match) 将匹配对象_match_写入 debug 对象_debug_中,用于调试。

See also Debugging Techniques

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QUrl &url) 将url_url_写入流_out_中,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QUrl &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &s, const QUuid &id) 将 UUID_id_写入到数据流_s_中。

暂无该属性

[public plain  ]

QDebug operator<<(QDebug dbg, const QUuid &id) 将 UUID_id_写入输出流,用于调试信息_dbg_。

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QCborValue &v)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QCborValue &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QCborArray &a)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QCborArray &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QCborMap &m)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QCborMap &)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &s, QFlags e)

暂无该属性

[private plain  ]

typename std::enable_if<std::is_enum::value, QDataStream &>::type & operator<<(QDataStream &s, const T &t)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QList &list) 将列表_list_写入到流_out_中。

该函数要求值型实现operator<<()

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QVector &vector) 将向量_vector_写入到流_out_中。

该函数要求值型实现operator<<()

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QSet &set) 将_set_写入到流_out_中。

该函数要求值型实现operator<<()

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QHash<Key, T> &hash) 将哈希值_hash_写入到流中。out

该函数要求键和值类型实现operator<<()

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QFileInfo &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, QDir::Filters filters)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const QDir &dir)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QPoint &point) 将给定的_point_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QPoint &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QPointF &point) 将给定的_point_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug d, const QPointF &p)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const QEasingCurve &item)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QEasingCurve &easing) 将给定的_easing_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QItemSelectionRange &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QJsonValue &)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QJsonValue &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QJsonArray &)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QJsonArray &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QJsonDocument &)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QJsonDocument &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QJsonObject &)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &, const QJsonObject &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QVersionNumber &version) 将版本号_version_写入到流_out_中。

注意,这与 QDataStream::version() 无关。

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QVersionNumber &version)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug d, const QLine &p)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QLine &line) 将给定的_line_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug d, const QLineF &p)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QLineF &line) 将给定的_line_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &out, const QLinkedList &list) 将链接列表写入到流中。

该函数要求值型实现operator<<()

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QMargins &m) 将给定的边距_m_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QMargins &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QMarginsF &m) 将给定的边距_m_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QMarginsF &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const QMimeType &mime)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const QOperatingSystemVersion &ov)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QSize &size) 将给定的_size_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QSize &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QSizeF &size) 将给定的_size_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QSizeF &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QRect &rectangle) 将给定的_rectangle_写入给定的_stream_中,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QRect &)

暂无该属性

[public plain  ]

QDataStream & operator<<(QDataStream &stream, const QRectF &rectangle) 将_rectangle_写入_stream_,并返回对流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QRectF &)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug , const QStorageInfo &)

暂无该属性

[private plain  ]

QDataStream & operator<<(QDataStream &ds, const QTimeZone &tz)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug dbg, const QTimeZone &tz)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const int *pool)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug debug, const QCFString &string)

暂无该属性

[private plain  ]

QDebug operator<<(QDebug dbg, const QPpsAttribute &attribute)

QString::operator<=

[public plain  ]

bool operator<=(QLatin1String other) const 如果该字符串在词法上小于等于参数字符串_other_,则返回True,否则返回false

这是一个重载函数。

QString::operator<=

[public plain  ]

bool operator<=(const char *other) const 这个函数重载了 operator<=()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator<=

[public plain  ]

bool operator<=(const QByteArray &other) const 这个函数重载了 operator<=()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString 。如果在字节数组中嵌入了任何 NULL字符(‘\0’),它们将被包含在转换中。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator=

[public copy-assign  ]

QString & operator=(const QString &other) 将_other_赋值给该字符串,并返回该字符串的引用。

QString::operator=

[public plain  ]

QString & operator=(QChar ch) 这个函数重载了 operator=()

将字符串设置为包含单个字符_ch_。

QString::operator=

[public plain  ]

QString & operator=(QLatin1String str) 这个函数重载了 operator=()

将 Latin-1 字符串_str_赋值给该字符串。

QString::operator=

[public move-assign  ]

QString & operator=(QString &&other) 将_other_赋值给该 QString 实例。

QString::operator=

[public plain  ]

QString & operator=(const char *str) 这个函数重载了 operator=()

将_str_赋值给该字符串。const char 指针使用 fromUtf8() 函数转换为 Unicode。

编译应用程序时,可以通过定义QT_NO_CAST_FROM_ASCIIQT_RESTRICTED_CAST_FROM_ASCII来禁用这个操作符。例如,如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII QT_RESTRICTED_CAST_FROM_ASCII

QString::operator=

[public copy-assign  ]

QString & operator=(const QByteArray &ba) 这个函数重载了 operator=()

将赋值给该字符串。使用 fromUtf8() 函数将字节数组转换为 Unicode。该函数在发现第一个NULL字符或_ba_字节数组结束时停止转换。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator=

[public plain  ]

QString & operator=(char ch) 这个函数重载了 operator=()

将字符_ch_赋值给该字符串。需要注意的是,这个字符是通过 fromLatin1() 函数转换为 Unicode 的,与其它操作 UTF-8 数据的8位函数不同。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator=

[private copy-assign  ]

QString & operator=(const QString::Null &)

QString::operator==

[public plain  ]

bool operator==(QLatin1String other) const 这是一个重载函数。

如果该字符串等于_other_,则返回True;否则返回false

QString::operator==

[public plain  ]

bool operator==(const char *other) const 这个函数重载了 operator==()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator==

[public plain  ]

bool operator==(const QByteArray &other) const 这个函数重载了 operator==()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString 。这个函数在发现第一个NULL字符或字节数组的末端停止转换。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

如果该字符串在词法上大于等于参数_other_,则返回True,否则返回false

See also QT_NO_CAST_FROM_ASCII

QString::operator>

[public plain  ]

bool operator>(QLatin1String other) const 这是一个重载函数。

如果该字符串在词法上大于等于参数_other_,则返回True,否则返回false

QString::operator>

[public plain  ]

bool operator>(const char *other) const 这个函数重载了 operator>()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator>

[public plain  ]

bool operator>(const QByteArray &other) const 这个函数重载了 operator>()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString 。如果在字节数组中嵌入了任何 NULL字符(‘\0’),它们将被包含在转换中。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator>=

[public plain  ]

bool operator>=(QLatin1String other) const 如果该字符串在词法上大于等于参数_other_,则返回True,否则返回false

这是一个重载函数。

QString::operator>=

[public plain  ]

bool operator>=(const char *other) const 这个函数重载了 operator>=()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::operator>=

[public plain  ]

bool operator>=(const QByteArray &other) const 这个函数重载了 operator>=()

另一个_other_字节数组使用 fromUtf8() 函数转换为 QString 。如果在字节数组中嵌入了任何 NULL字符(‘\0’),它们将被包含在转换中。

可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII来禁用这个操作符。如果想确保所有用户可见的字符串都经过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QString &string) 从指定的流_stream_中读取一个字符串到给定的_string_中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QRegExp &regExp) 从流_in_中读取一个正则表达式到中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &s, QVariant &p) 从流_s_中读取一个变体到中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &s, QVariant::Type &p) 从流_s_中读取一个枚举表示的变体类型到_p_中。

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QBitArray &ba) 从流中读取一个位属组到_ba_中。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QLocale &)

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QDate &date) 从流_in_中读取一个日期到_date_中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QTime &time) 从流_in_中读取一个时间到给定的中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QDateTime &dateTime) 从流_in_中读取一个日期时间到中。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QTextStream & operator>>(QTextStream &s, QTextStreamFunction f)

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &ds, QCborSimpleType &st)

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QRegularExpression &re) 从流_in_中读取正则表达式到中。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QUrl &url) 从流_in_中读取一个url到_url_中,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &s, QUuid &id) 从流_s_中读取一个UUID到_id_中。

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QCborValue &)

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QCborArray &)

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QCborMap &)

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &s, QFlags &e)

暂无该属性

[private plain  ]

typename std::enable_if<std::is_enum::value, QDataStream &>::type & operator>>(QDataStream &s, T &t)

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QVector &vector) 从流_in_中读取一个向量到_vector_中。

该函数要求值类型实现。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QHash<Key, T> &hash) 将流_in_中的哈希值读入_hash_。

该函数要求键和值类型实现operator>>()

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QPoint &point) 在给定_point_中,从给定_stream_中读取一个坐标,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QPointF &point) 在给定_point_中,从给定_stream_中读取一个坐标,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QEasingCurve &easing) 在给定缓和曲线_easing_中,从给定_stream_中读取缓和曲线,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QJsonValue &)

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QJsonArray &)

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QJsonDocument &)

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &, QJsonObject &)

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QVersionNumber &version) 从流_in_中读取版本号并存储在_version_中。

注意,这与 QDataStream::version() 无关。

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QLine &line) 在给定_line_中,从给定_stream_中读取一行,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QLineF &line) 从给定_line_中,从给定_stream_中读取一行,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &in, QLinkedList &list) 从流_in_中读取链接列表到_list_中。

此函数需要值类型来实现operator>>()

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QMargins &m) 在给定的边距_m_中,从给定_stream_中读取一个边距,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QMarginsF &m) 在给定的边距_m_中,从给定_stream_中读取一个边距,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QSize &size) 在给定的_size_中,从给定_stream_中读取一个大小,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QSizeF &size) 在给定的_size_中,从给定_stream_中读取一个大小,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QRect &rectangle) 在给定的_rectangle_中,从给定_stream_中的读取一个矩形,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[public plain  ]

QDataStream & operator>>(QDataStream &stream, QRectF &rectangle) 从_stream_中读取一个矩形_rectangle_,并返回对该流的引用。

See also Serializing Qt Data Types

暂无该属性

[private plain  ]

QDataStream & operator>>(QDataStream &ds, QTimeZone &tz)

QString::operator[]

[public plain  ]

QCharRef operator[](int position) 返回字符串中指定_position_的字符作为可修改的引用。

例子:

返回值是 QCharRef 类型,它是 QString 的帮助器类。当获得类型为 QCharRef 的对象时,可以将其当作对 QChar 的引用来使用。如果分配给它,则分配将应用于从中获取引用的 QString 中的字符。

注意:在 Qt 5.14之前,可以使用此运算符在字符串的越界位置访问字符,然后分配给该位置,从而自动调整字符串的大小。此外,即使同时复制了字符串(并且在进行复制时 QCharRef 仍保持活动状态),将值分配给返回的 QCharRef 也会导致字符串分离。这些行为已被弃用,并将在以后的 Qt 版本中进行更改。

See also at()

QString::operator[]

[public plain  ]

const QChar operator[](int position) const 此函数重载 operator

QString::operator[]

[public plain  ]

const QChar operator[](uint position) const 等效于at(position)。此函数重载 operator .

QString::operator[]

[public plain  ]

QCharRef operator[](uint position) 此函数重载 operator

返回字符串中指定_position_的字符作为可修改的引用。

QString::prepend

[public plain  ]

QString & prepend(const QString &str) 将字符串_str_放在此字符串首部,并返回对该字符串的引用。

例子:

See also append() insert()

QString::prepend

[public plain  ]

QString & prepend(QChar ch) 此函数重载 prepend()

在该字符串前添加字符_ch_。

QString::prepend

[public plain  ]

QString & prepend(const QChar *str, int len) 此函数重载 prepend()

QChar 数组_str_中的_len_个字符添加到此字符串中,并返回对该字符串的引用。

QString::prepend

[public plain  ]

QString & prepend(const QStringRef &str) 此函数重载 prepend()

将字符串引用_str_附加到该字符串首部,并返回对该字符串的引用。

QString::prepend

[public plain  ]

QString & prepend(QLatin1String str) 此函数重载 prepend()

将 Latin-1 字符串_str_附加到此字符串首部。

QString::prepend

[public plain  ]

QString & prepend(QStringView str) 将给定的字符串_str_附加到此字符串并返回结果。

注意:此方法已在5.15.2中添加,以简化编写可在 Qt 5.15和 Qt 6之间移植的代码的过程。

QString::prepend

[public plain  ]

QString & prepend(const char *str) 此函数重载 prepend()

将字符串_str_附加到此字符串。使用 fromUtf8() 函数将 const char 指针转换为 Unicode。

可以在编译应用程序时通过定义QT_NO_CAST_FROM_ASCII来禁用此功能。例如,如果要确保所有用户可见的字符串都通过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::prepend

[public plain  ]

QString & prepend(const QByteArray &ba) 此函数重载 prepend()

将字节数组_ba_附加到此字符串。使用 fromUtf8() 函数将字节数组转换为 Unicode。

可以在编译应用程序时通过定义QT_NO_CAST_FROM_ASCII来禁用此功能。例如,如果要确保所有用户可见的字符串都通过 QObject::tr() ,则此功能很有用。

See also QT_NO_CAST_FROM_ASCII

QString::push_back

[public plain  ]

void push_back(const QString &other) 提供此函数是为了实现 STL 兼容性,它会将给定的_other_字符串附加到该字符串的尾部。它等效于append(other)

See also append()

QString::push_back

[public plain  ]

void push_back(QChar ch) 这是一个重载函数。

将给定的_ch_字符附加到此字符串的末尾。

QString::push_front

[public plain  ]

void push_front(const QString &other) 提供此功能是为了实现STL兼容性,将给定的other字符串放在此字符串的开头。 它等效于prepend(other)

See also prepend()

QString::push_front

[public plain  ]

void push_front(QChar ch) 这是一个重载函数。

将给定的_ch_字符添加到此字符串的首部。

QString::rbegin

[public plain  ]

QString::reverse_iterator rbegin() 返回一个 STL-style iterators 的反向迭代器,以反向顺序指向字符串中最后一个字符。

See also begin() crbegin() rend()

QString::rbegin

[public plain  ]

QString::const_reverse_iterator rbegin() const 这是一个重载函数。

QString::reallocData

[private plain  ]

void reallocData(uint alloc, bool grow)

QString::remove

[public plain  ]

QString & remove(int position, int n) 从给定位置_position_索引开始,从字符串中删除_n_个字符,并返回对该字符串的引用。

如果指定的位置_position_索引在字符串中,但_position_+_n_超出字符串的末尾,则字符串将在指定_position_被截断。

See also insert() replace()

QString::remove

[public plain  ]

QString & remove(QChar ch, Qt::CaseSensitivity cs) 删除此字符串中每次出现的给定_ch_字符,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

例子:

这与replace(ch, "", cs)相同。

See also replace()

QString::remove

[public plain  ]

QString & remove(QLatin1String str, Qt::CaseSensitivity cs) 这是一个重载函数。

删除此字符串中每次出现的给定_str_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

这与replace(str, "", cs)相同。

See also replace()

QString::remove

[public plain  ]

QString & remove(const QString &str, Qt::CaseSensitivity cs) 删除此字符串中每次出现的给定_str_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

这与replace(str, "", cs)相同。

See also replace()

QString::remove

[public plain  ]

QString & remove(const QRegExp &rx) 删除字符串中每次出现的正则表达式_rx_,并返回对该字符串的引用。例如:

See also indexOf() lastIndexOf() replace()

QString::remove

[public plain  ]

QString & remove(const QRegularExpression &re) 删除字符串中所有出现的正则表达式_re_,并返回对该字符串的引用。例如:

See also indexOf() lastIndexOf() replace()

QString::rend

[public plain  ]

QString::reverse_iterator rend() 返回一个 STL-style iterators 的反向迭代器,以反向顺序指向字符串中最后一个字符。

See also end() crend() rbegin()

QString::rend

[public plain  ]

QString::const_reverse_iterator rend() const 这是一个重载函数。

QString::repeated

[public plain  ]

QString repeated(int times) const 返回此字符串的副本,重复指定的_times_次数。

如果_times_小于1,则返回一个空字符串。

例子:

QString::replace

[public plain  ]

QString & replace(int position, int n, const QString &after) 将从索引_position_开始的_n_个字符替换为_after_字符串,并返回对该字符串的引用。

注意::如果指定的位置_position_索引在字符串内,但_position_+ _n_超出字符串范围,则将调整_n_到字符串末尾停止。

例子:

See also insert() remove()

QString::replace

[public plain  ]

QString & replace(int position, int n, QChar after) 这个函数重载了 replace()

将从索引_position_开始的_n_个字符替换为_after_字符,并返回对该字符串的引用。

QString::replace

[public plain  ]

QString & replace(int position, int n, const QChar *unicode, int size) 这个函数重载了 replace()

将从索引_position_开始的_n_个字符替换为第一个_size_大小的 QChar 数组_unicode_,并返回对该字符串的引用。

QString::replace

[public plain  ]

QString & replace(QChar before, QChar after, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_before_字符替换为_after_字符,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

QString::replace

[public plain  ]

QString & replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_before_字符开始到_blen_个字符替换为从_after_开始到_alen_个字符,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

QString::replace

[public plain  ]

QString & replace(QLatin1String before, QLatin1String after, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_before_字符串替换为_after_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

注意:替换后的文本不会被重新扫描。

QString::replace

[public plain  ]

QString & replace(QLatin1String before, const QString &after, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_before_字符串替换为_after_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

注意:替换后的文本不会被重新扫描。

QString::replace

[public plain  ]

QString & replace(const QString &before, QLatin1String after, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_before_字符串替换为_after_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

注意:替换后的文本不会被重新扫描。

QString::replace

[public plain  ]

QString & replace(const QString &before, const QString &after, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_before_字符串替换为_after_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

例如:

注意:替换后的文本不会被重新扫描。

例如:

QString::replace

[public plain  ]

QString & replace(QChar ch, const QString &after, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_ch_字符替换为_after_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

QString::replace

[public plain  ]

QString & replace(QChar c, QLatin1String after, Qt::CaseSensitivity cs) 这个函数重载了 replace()

将每次出现的_c_字符替换为_after_字符串,并返回对该字符串的引用。

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

注意:替换后的文本不会被重新扫描。

QString::replace

[public plain  ]

QString & replace(const QRegExp &rx, const QString &after) 这个函数重载了 replace()

将每次出现的_rx_正则表达式替换为_after_字符串,并返回对该字符串的引用。例如:

对于包含 capturing parentheses 的正则表达式,在后面出现的 \1, \2, ..., 用 rx.cap(1), cap(2), ...代替。

See also indexOf() lastIndexOf() remove() QRegExp::cap()

QString::replace

[public plain  ]

QString & replace(const QRegularExpression &re, const QString &after) 这个函数重载了 replace()

将每次出现的_re_正则表达式替换为_after_字符串,并返回对该字符串的引用。例如:

对于包含捕获组的正则表达式,在后面出现的\1\2,...,会被相应的捕获组捕获的字符串所取代。

See also indexOf() lastIndexOf() remove() QRegularExpression QRegularExpressionMatch

QString::replace_helper

[private plain  ]

void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen)

QString::reserve

[public plain  ]

void reserve(int size) 试图为至少_size_字符分配内存。如果事先知道字符串会有多大,可以调用这个函数,如果经常调整字符串的大小,很可能会获得更好的性能。如果_size_是低估了,最坏的情况是 QString 会慢一点。

这个函数的唯一目的是提供一种微调 QString 内存使用情况的方法。一般来说,很少需要调用这个函数。如果想改变字符串的大小,调用 resize()

这个函数对于那些需要建立一个长字符串并希望避免重复分配的代码很有用。在这个例子中,希望向字符串中添加内容,直到某个条件为True,并且相当确定这个大小足够大,所以调用这个函数是值得的。

See also squeeze() capacity()

QString::resize

[public plain  ]

void resize(int size) 将字符串的大小设置为_size_字符。

如果_size_大于当前的大小,字符串将被扩展,使其成为_size_字符的长度,并在最后添加额外的字符。新的字符是未初始化的。

如果_size_小于当前的大小,则从末尾删除字符。

例如:

如果想在字符串中附加一定数量的相同字符,可以使用 QString::resize(int, QChar) 重载。 QString::resize(int, QChar)

如果想展开字符串,使其达到一定的宽度,并用特定的字符填充新的位置,使用 leftJustified() 函数。

如果_size_为负数,就相当于传零。

See also truncate() reserve()

QString::resize

[public plain  ]

void resize(int size, QChar fillChar) 这是一个重载函数。

QString::resize(int) 不同,这个重载将新字符初始化为_fillChar_。

QString::right

[public plain  ]

QString right(int n) const 返回一个包含字符串最右边_n_个字符的子串。

如果_n_大于等于 size() ,或者小于0,则返回整个字符串。

See also left() mid() endsWith() chopped() chop() truncate()

QString::rightJustified

[public plain  ]

QString rightJustified(int width, QChar fill, bool truncate) const 返回一个_width_为 size() 的字符串,该字符串后面包含_fill_字符。例如:

如果_truncate_为false,并且字符串的 size() 大于_width_,那么返回的字符串就是该字符串的副本。

如果_truncate_为真,并且字符串的 size() 大于_width_,那么产生的字符串在位置_width_处被截断。

See also leftJustified()

QString::rightRef

[public plain  ]

QStringRef rightRef(int n) const 返回字符串中最右边的_n_个字符的子串引用。

如果_n_大于等于 size() ,或者小于0,则返回整个字符串的引用。

See also right() leftRef() midRef() endsWith()

QString::section

[public plain  ]

QString section(QChar sep, int start, int end, QString::SectionFlags flags) const 该函数返回字符串的选中部分。

该字符串被视为由字符_sep_分隔的字段序列,返回的字符串包括从位置_start_到位置_end_的字段。如果没有指定_end_,则包括从位置_start_到字符串结束的所有字段。从左边开始计算,字段编号为0、1、2等,从右到左计算,-1、-2等,。

_flags_参数可以用来影响某些方面的函数行为,例如是否区分大小写,是否跳过空字段,以及如何处理首尾分隔符;参见 SectionFlags

如果_start_或_end_为负数,我们从字符串的右边开始计算字段,最右边的字段为-1,最右边字段的右边为-2,以此类推。

See also split()

QString::section

[public plain  ]

QString section(const QString &sep, int start, int end, QString::SectionFlags flags) const 这个函数重载了 section()

See also split()

QString::section

[public plain  ]

QString section(const QRegExp &reg, int start, int end, QString::SectionFlags flags) const 这个函数重载了 section()

这个字符串被视为一个由正则表达式 Reg 分隔的字段序列。

警告:使用这个 QRegExp 版本比重载的字符串和字符版本要高昂得多。

See also split() simplified()

QString::section

[public plain  ]

QString section(const QRegularExpression &re, int start, int end, QString::SectionFlags flags) const 这个函数重载了 section()

这个字符串被视为由正则表达式分隔的字段序列,_re_。

使用这个 QRegularExpression 版本比重载字符串和字符版本要高昂得多。

See also split() simplified()

QString::setNum

[public plain  ]

QString & setNum(int n, int base) 将字符串设置为指定_base_中_n_的打印值,并返回字符串的引用。

基数默认为10,必须在2和36之间。对于10以外的基数,_n_将作为无符号整数处理。

格式化总是使用 QLocale::C ,即 English/UnitedStates。要获得一个数字的本地化字符串表示,使用 QLocale::toString() 和适当的 locale。

See also number()

QString::setNum

[public plain  ]

QString & setNum(short n, int base) 这是一个重载函数。

QString::setNum

[public plain  ]

QString & setNum(ushort n, int base) 这是一个重载函数。

QString::setNum

[public plain  ]

QString & setNum(uint n, int base) 这是一个重载函数。

QString::setNum

[public plain  ]

QString & setNum(long n, int base) 这是一个重载函数。

QString::setNum

[public plain  ]

QString & setNum(ulong n, int base) 这是一个重载函数。

QString::setNum

[public plain  ]

QString & setNum(qlonglong n, int base) 这是一个重载函数。

QString::setNum

[public plain  ]

QString & setNum(qulonglong n, int base) 这是一个重载函数。

QString::setNum

[public plain  ]

QString & setNum(float n, char format, int precision) 这是一个重载函数。

将字符串设置为_n_的打印值,按照给定的_format_和_precision_进行格式化,并返回字符串的引用。

格式化总是使用 QLocale::C ,即 English/UnitedStates。要获得一个数字的本地化字符串表示,使用 QLocale::toString() 和适当的 locale。

See also number()

QString::setNum

[public plain  ]

QString & setNum(double n, char format, int precision) 这是一个重载函数。

将字符串设置为_n_的打印值,按照给定的_format_和_precision_进行格式化,并返回字符串的引用。

_format_可以是‘e‘、‘E‘、‘f‘、‘g‘或‘G‘(关于格式的解释请参见 Argument Formats )。

格式化总是使用 QLocale::C ,即 English/UnitedStates。要获得一个数字的本地化字符串表示,使用 QLocale::toString() 和适当的 locale。

See also number()

QString::setRawData

[public plain  ]

QString & setRawData(const QChar unicode, int size) 重置 QString ,使用数组_unicode_中第一个_size_的 Unicode 字符。_unicode_中的数据not*被复制。调用者必须能够保证只要 QString (或其未修改的副本)存在,_unicode_就不会被删除或修改。

这个函数可以代替 fromRawData() 来重用存在的 QString 对象,以节省重新分配的内存。

See also fromRawData()

QString::setUnicode

[public plain  ]

QString & setUnicode(const QChar *unicode, int size) 将字符串调整为_size_字符,并将_unicode_复制到字符串中。

如果_unicode_为0,则不会复制任何东西,但仍会调整字符串的_size_。

See also unicode() setUtf16()

QString::setUtf16

[public plain  ]

QString & setUtf16(const ushort *unicode, int size) 将字符串调整为_size_字符,并将_unicode_复制到字符串中。

如果_unicode_为0,则不会复制任何东西,但仍会调整字符串的_size_。

请注意,与 fromUtf16() 不同,这个函数不考虑 BOM 和可能的不同字节排序。

See also utf16() setUnicode()

QString::shrink_to_fit

[public plain  ]

void shrink_to_fit() 这个函数是为了兼容 STL 而提供的。它相当于 squeeze()

See also squeeze()

QString::simplified

[public plain  ]

QString simplified() const 返回一个字符串,该字符串的首尾都去掉了空白符,并且每个序列的内部连续空白符都被替换为一个空白符。

空白符指的是 QChar::isSpace() 返回True的任何字符。这包括 ASCII 字符‘\t’, ‘\n‘, ‘\v‘, ‘\f‘, ‘\r‘和‘ ‘。

例如:

See also trimmed()

QString::simplified_helper

[private plain static ]

QString simplified_helper(const QString &str)

QString::simplified_helper

[private plain static ]

QString simplified_helper(QString &str)

QString::size

[public plain  ]

int size() const 返回此字符串中的字符数。

字符串中的最后一个字符在-1位置。

例如:

See also isEmpty() resize()

QString::split

[public plain  ]

QStringList split(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const 在_sep_出现的地方将字符串分割成子串,并返回这些字符串的列表。如果_sep_在字符串中的任何地方都不匹配,则返回一个包含该字符串的单元素列表。

_cs_指定_sep_是否应按大小写敏感或不敏感匹配。

如果_behavior_是 Qt::SkipEmptyParts ,空条目不会出现在结果中。默认情况下,空条目被保留。

例如:

如果_sep_为空,返回一个空字符串,后面是字符串的每个字符,再后面是另一个空字符串:

为了理解这种行为,请回想一下,空字符串在任何地方都是匹配的,所以与上面的性质相同:

See also QStringList::join() section()

QString::split

[public plain  ]

QStringList split(const QString &sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const 这是一个重载函数。

QString::split

[public plain  ]

QStringList split(QChar sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const 这是一个重载函数。

QString::split

[public plain  ]

QStringList split(const QRegExp &rx, QString::SplitBehavior behavior) const 这是一个重载函数。

QString::split

[public plain  ]

QStringList split(const QRegularExpression &re, QString::SplitBehavior behavior) const 这是一个重载函数。

QString::split

[public plain  ]

QStringList split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const 这是一个重载函数。

QString::split

[public plain  ]

QStringList split(const QRegExp &rx, Qt::SplitBehavior behavior) const 这是一个重载函数。

将字符串分割成正则表达式_rx_匹配的子串,并返回这些字符串的列表。如果_rx_在字符串中没有匹配的地方, split() 返回一个包含这个字符串的单元素列表。

下面是一个例子,使用一个或多个空白字符作为分隔符来提取句子中的单词:

下面是一个类似的例子,但这次使用任何非单词字符序列作为分隔符:

这里是第三个例子,使用零长度的断言,\b(词边界),将字符串分割成非词和词标记的交替序列:

See also QStringList::join() section()

QString::split

[public plain  ]

QStringList split(const QRegularExpression &re, Qt::SplitBehavior behavior) const 这是一个重载函数。

将字符串分割成正则表达式_re_匹配的子串,并返回这些字符串的列表。如果_re_在字符串中没有匹配的地方, split() 返回一个包含这个字符串的单元素列表。

下面是一个例子,使用一个或多个空白字符作为分隔符来提取句子中的单词:

下面是一个类似的例子,但这次使用任何非单词字符序列作为分隔符:

这里是第三个例子,使用零长度的断言,\b(词边界),将字符串分割成非词和词标记的交替序列:

See also QStringList::join() section()

QString::splitRef

[public plain  ]

QVector splitRef(const QString &sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const 在出现_sep_的地方将字符串分割成子串引用,并返回这些字符串的列表。

参见 QString::split() ,了解_sep_、_behavior_和_cs_如何交互形成结果。

注意:只要这个字符串还存在,所有的引用都是有效的。销毁这个字符串将导致所有的引用都是空指针。

See also QStringRef split()

QString::splitRef

[public plain  ]

QVector splitRef(const QString &sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const 这是一个重载函数。

QString::splitRef

[public plain  ]

QVector splitRef(QChar sep, QString::SplitBehavior behavior, Qt::CaseSensitivity cs) const 这是一个重载函数。

QString::splitRef

[public plain  ]

QVector splitRef(const QRegExp &rx, QString::SplitBehavior behavior) const 这是一个重载函数。

QString::splitRef

[public plain  ]

QVector splitRef(const QRegularExpression &re, QString::SplitBehavior behavior) const 这是一个重载函数。

QString::splitRef

[public plain  ]

QVector splitRef(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const 这是一个重载函数。

QString::splitRef

[public plain  ]

QVector splitRef(const QRegExp &rx, Qt::SplitBehavior behavior) const 这是一个重载函数。

将字符串分割成正则表达式_rx_匹配的子串引用,并返回这些字符串的列表。如果_rx_在字符串中没有匹配的地方, splitRef() 返回一个包含这个字符串引用的单元素向量。

注意:只要这个字符串还存在,所有的引用都是有效的。销毁这个字符串将导致所有的引用都是空指针。

See also QStringRef split()

QString::splitRef

[public plain  ]

QVector splitRef(const QRegularExpression &re, Qt::SplitBehavior behavior) const 这是一个重载函数。

将字符串分割成正则表达式_re_匹配的子串引用,并返回这些字符串的列表。如果_re_在字符串中没有任何地方匹配, splitRef() 返回一个包含这个字符串引用的单元素向量。

注意:只要这个字符串还存在,所有的引用都是有效的。销毁这个字符串将导致所有的引用都是空指针。

See also split() QStringRef

QString::sprintf

[public plain  ]

QString & sprintf(const char *cformat, ... ) 使用 asprintf()arg()QTextStream 代替。

QString::squeeze

[public plain  ]

void squeeze() 释放任何不需要存储字符数据的内存。

这个函数的唯一目的是提供一种微调 QString 内存使用情况的方法。一般来说,很少需要调用这个函数。

See also reserve() capacity()

QString::startsWith

[public plain  ]

bool startsWith(const QString &s, Qt::CaseSensitivity cs) const 如果字符串以字符串_s_开始,则返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also endsWith()

QString::startsWith

[public plain  ]

bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs) const 这是一个重载函数。

如果字符串以字符串引用_s_开始,则返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),则搜索区分大小写;否则搜索不区分大小写。

See also endsWith()

QString::startsWith

[public plain  ]

bool startsWith(QStringView str, Qt::CaseSensitivity cs) const 这是一个重载函数。

如果字符串以字符串视图_str_开头,则返回True;否则返回false

如果_cs_是 Qt::CaseSensitive (默认),搜索区分大小写,否则搜索不区分大小写。

See also endsWith()

QString::startsWith

[public plain  ]

bool startsWith(QLatin1String s, Qt::CaseSensitivity cs) const 这个函数重载了 startsWith()

QString::startsWith

[public plain  ]

bool startsWith(QChar c, Qt::CaseSensitivity cs) const 这个函数重载了 startsWith()

如果字符串以_c_开头,则返回True;否则返回false

QString::swap

[public plain  ]

void swap(QString &other) 将_other_与这个字符串交换。这个操作非常快,并且从来没有失败过。

QString::toAscii

[public plain  ]

QByteArray toAscii() const 返回一个8位以 QByteArray 表示的字符串。

这个函数和 toLatin1() 的做法一样。

请注意,尽管使用这个函数名字,但它不一定会返回一个 US-ASCII (ANSI X3.4-1986)字符串,而且它的结果可能与 US-ASCII 不兼容。

See also fromAscii() toLatin1() toUtf8() toLocal8Bit() QTextCodec

QString::toCFString

[public plain  ]

CFStringRef toCFString() const 从一个 QString 创建一个 CFString。调用者拥有 CFString 并负责释放它。

注意:该功能仅在 OS X 和 IOS 上可用。

QString::toCaseFolded

[public plain  ]

QString toCaseFolded() const 返回字符串的大小写等价物。对于大多数U nicode 字符,这与 toLower() 相同。

QString::toCaseFolded_helper

[private plain static ]

QString toCaseFolded_helper(const QString &str)

QString::toCaseFolded_helper

[private plain static ]

QString toCaseFolded_helper(QString &str)

QString::toDouble

[public plain  ]

double toDouble(bool *ok) const 返回字符串转换为double的值。

由于其它原因(如下标越界),如果转换溢出,则返回无穷大,如果转换失败,则返回0.0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

警告: QString 内容可能只包含有效的数字字符,包括正负号,科学符号中使用的字符e,以及小数点。添加单位或附加字符会导致转换错误。

字符串的转换总是发生在‘C‘语言环境下。对于依赖于本地语言的转换,使用 QLocale::toDouble()

由于历史原因,这个函数不处理千组分隔符。如果需要转换这些数字,请使用 QLocale::toDouble()

该函数忽略首尾空白符。

See also number() QLocale::setDefault() QLocale::toDouble() trimmed()

QString::toFloat

[public plain  ]

float toFloat(bool *ok) const 返回字符串转换为float的值。

由于其它原因(如下标越界),如果转换溢出,则返回无穷大,如果转换失败,则返回0.0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

警告: QString 内容可能只包含有效的数字字符,包括正负号,科学符号中使用的字符e,以及小数点。添加单位或附加字符会导致转换错误。

字符串的转换总是发生在‘C‘语言环境下。对于依赖于本地语言的转换,使用 QLocale::toFloat()

由于历史原因,该函数不处理千组分隔符。如果需要转换这样的数字,请使用 QLocale::toFloat()

例如:

该函数忽略首尾空白符。

See also number() toDouble() toInt() QLocale::toFloat() trimmed()

QString::toHtmlEscaped

[public plain  ]

QString toHtmlEscaped() const 将纯文本字符串转换为HTML字符串,并将HTML元字符<>&"替换为HTML实体。

例如:

QString::toInt

[public plain  ]

int toInt(bool *ok, int base) const 返回使用_base_将字符串转换为int的结果,默认为10,并且必须在2和36之间,或者0,如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用C语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以"0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C‘语言环境下。对于依赖于本地语言的转换,使用 QLocale::toInt()

例如:

该函数忽略首尾空白符。

See also number() toUInt() toDouble() QLocale::toInt()

QString::toIntegral_helper

[private plain static ]

qlonglong toIntegral_helper(const QChar *data, int len, bool *ok, int base)

QString::toIntegral_helper

[private plain static ]

qulonglong toIntegral_helper(const QChar *data, uint len, bool *ok, int base)

QString::toLatin1

[public plain  ]

QByteArray toLatin1() const 返回字符串作为一个 QByteArray 的 Latin-1 表示形式。

如果字符串中包含非拉丁字符,则返回的字节数组未定义。这些字符可以被抑制或用问号代替。

See also fromLatin1() toUtf8() toLocal8Bit() QTextCodec

QString::toLatin1_helper

[private plain static ]

QByteArray toLatin1_helper(const QString &)

QString::toLatin1_helper_inplace

[private plain static ]

QByteArray toLatin1_helper_inplace(QString &)

QString::toLocal8Bit

[public plain  ]

QByteArray toLocal8Bit() const 返回字符串作为 QByteArray 的本地8位表示形式。如果字符串中包含本地8位编码不支持的字符,则返回的字节数组将不被定义。

QTextCodec::codecForLocale() 用于执行 Unicode 的转换。如果无法确定本地语言编码,这个函数的作用和 toLatin1() 一样。

如果这个字符串包含任何不能在本地中编码的字符,返回的字节数组是未定义的。这些字符可能会被抑制或被其它字符取代。

See also fromLocal8Bit() toLatin1() toUtf8() QTextCodec

QString::toLocal8Bit_helper

[private plain static ]

QByteArray toLocal8Bit_helper(const QChar *data, int size)

QString::toLong

[public plain  ]

long toLong(bool *ok, int base) const 返回使用_base_将字符串转换为long的结果,默认为10,且必须在2和36之间,或者0,如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用C语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以"0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换,使用 QLocale::toLongLong()

例如:

该函数忽略首尾空白符。

See also number() toULong() toInt() QLocale::toInt()

QString::toLongLong

[public plain  ]

qlonglong toLongLong(bool *ok, int base) const 返回使用_base_转换为long long的字符串,默认为10,必须在2和36之间,如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用C语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以"0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换,使用 QLocale::toLongLong()

例如:

该函数忽略首尾空白符。

See also number() toULongLong() toInt() QLocale::toLongLong()

QString::toLower

[public plain  ]

QString toLower() const 返回字符串的小写副本。

大小写转换总是发生在‘C’语言环境中。对于依赖于本地语言的大小写转换,使用 QLocale::toLower()

See also toUpper() QLocale::toLower()

QString::toLower_helper

[private plain static ]

QString toLower_helper(const QString &str)

QString::toLower_helper

[private plain static ]

QString toLower_helper(QString &str)

QString::toNSString

[public plain  ]

NSString * toNSString() const 从一个 QString 创建一个 NSString。NSString 是自动释放的。

注意:该功能仅在 OS X 和 iOS 上可用。

QString::toShort

[public plain  ]

short toShort(bool *ok, int base) const 返回使用_base_将该字符串转换为short的结果,默认为10,必须在2和36之间,或者0。如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用C语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以"0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换,使用 QLocale::toShort()

例如:

该函数忽略首尾空白符。

See also number() toUShort() toInt() QLocale::toShort()

QString::toStdString

[public plain  ]

std::string toStdString() const 返回一个包含 QString 数据的 std::string 对象。使用 toUtf8() 函数将Unicode数据转换为8位字符。

这个方法主要用于传递一个 QString 到一个接受 std::string 对象的函数。

See also toLatin1() toUtf8() toLocal8Bit() QByteArray::toStdString()

QString::toStdU16String

[public plain  ]

std::u16string toStdU16String() const 返回一个包含 QString 中数据的 std::u16string 对象。Unicode 数据与 utf16() 方法返回的数据相同。

See also utf16() toStdWString() toStdU32String()

QString::toStdU32String

[public plain  ]

std::u32string toStdU32String() const 返回一个包含 QString 中数据的 std::u32string 对象。Unicode 数据与 toUcs4() 方法返回的数据相同。

See also toUcs4() toStdWString() toStdU16String()

QString::toStdWString

[public plain  ]

std::wstring toStdWString() const 返回一个包含 QString 中数据的 std::wstring 对象。在 wchar_t 为2字节宽的平台上,std::wstring 的编码是 UTF-16(例如 Windows),在 wchar_t 为4字节宽的平台上,std::wstring 的编码是 UCS-4(大多数 Unix 系统)。

这个方法主要用于将一个 QString 传递给一个接受 std::wstring 对象的函数。

See also utf16() toLatin1() toUtf8() toLocal8Bit() toStdU16String() toStdU32String()

QString::toUInt

[public plain  ]

uint toUInt(bool *ok, int base) const 返回使用_base_将字符串转换为unsigned int的结果,默认为10,必须在2和36之间,或者0。如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用C语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以"0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换,使用 QLocale::toUInt()

例如:

该函数忽略首尾空白符。

See also number() toInt() QLocale::toUInt()

QString::toULong

[public plain  ]

ulong toULong(bool *ok, int base) const 返回使用_base_将字符串转换为unsigned long的结果,默认为10,必须在2和36之间,或者0。如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用C语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以"0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换,使用 QLocale::toULongLong()

例如:

该函数忽略首尾空白符。

See also number() QLocale::toUInt()

QString::toULongLong

[public plain  ]

qulonglong toULongLong(bool *ok, int base) const 返回使用_base_将字符串转换为unsigned long long的结果,默认为10,必须在2和36之间,如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用C语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以 "0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换,使用 QLocale::toULongLong()

例如:

该函数忽略首尾空白符。

See also number() toLongLong() QLocale::toULongLong()

QString::toUShort

[public plain  ]

ushort toUShort(bool *ok, int base) const 返回使用_base_将字符串转换为unsigned short的结果,默认为10,必须在2和36之间,如果转换失败,返回0。

如果_ok_不为nullptr,则通过设置*_ok_为false来报告失败,设置*_ok_为True来报告成功。

如果_base_为0,则使用 C 语言惯例:如果字符串以"0x"开头,使用基数16;如果字符串以"0"开头,使用基数8;否则,使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换,使用 QLocale::toUShort()

例如:

该函数忽略首尾空白符。

See also number() toShort() QLocale::toUShort()

QString::toUcs4

[public plain  ]

QVector toUcs4() const 返回一个 UCS-4/UTF-32 表示的 QVector 字符串。

UCS-4 是一种 Unicode 编解码器,因此它是无损的。这个字符串中的所有字符都将用 UCS-4 编码。在这个字符串中,任何无效的代码单位序列都会被 Unicode 的替换字符( QChar::ReplacementCharacter ,对应U+FFFD)所取代。

返回的向量不是以‘\0’结束的。

See also fromUtf8() toUtf8() toLatin1() toLocal8Bit() QTextCodec fromUcs4() toWCharArray()

QString::toUcs4_helper

[private plain static ]

int toUcs4_helper(const ushort *uc, int length, uint *out)

QString::toUpper

[public plain  ]

QString toUpper() const 返回字符串的大写副本。

大小写转换总是发生在‘C’语言环境中。对于依赖于本地语言的大小写转换,使用 QLocale::toUpper()

See also toLower() QLocale::toLower()

QString::toUpper_helper

[private plain static ]

QString toUpper_helper(const QString &str)

QString::toUpper_helper

[private plain static ]

QString toUpper_helper(QString &str)

QString::toUtf8

[public plain  ]

QByteArray toUtf8() const 返回一个用 UTF-8 表示的 QByteArray 字符串。

UTF-8 是一种 Unicode 编解码器,可以表示 Unicode 字符串中的所有字符,如 QString

See also fromUtf8() toLatin1() toLocal8Bit() QTextCodec

QString::toUtf8_helper

[private plain static ]

QByteArray toUtf8_helper(const QString &)

QString::toWCharArray

[public plain  ]

int toWCharArray(wchar_t *array) const 用 QString 对象中的数据填充_array_。在 wchar_t 为2字节宽的平台上,数组用 UTF-16 编码(例如 Windows),在 wchar_t 为4字节宽的平台上,数组用 UCS-4 编码(大多数 Unix 系统)。

_array_必须由调用者分配,并包含足够的空间来容纳完整的字符串(分配与字符串长度相同的数组总是足够的)。

该函数返回_array_中字符串的实际长度。

注意:这个函数不会在数组中附加一个空字符。

See also utf16() toUcs4() toLatin1() toUtf8() toLocal8Bit() toStdWString() QStringView::toWCharArray()

QString::trimmed

[public plain  ]

QString trimmed() const 返回一个去掉首尾空白符的字符串。

空白符指的是 QChar::isSpace() 返回True的任何字符。这包括 ASCII 字符‘\t’, ‘\n’, ‘\v’, ‘\f’, ‘\r’和‘ ’。

例如:

simplified() 不同的是,只留下内部空白符。

See also simplified()

QString::trimmed_helper

[private plain static ]

QString trimmed_helper(const QString &str)

QString::trimmed_helper

[private plain static ]

QString trimmed_helper(QString &str)

QString::truncate

[public plain  ]

void truncate(int position) 在给定的_position_索引处截断字符串。

如果指定的_position_索引超出了字符串的末端,则不会发生任何事情。

例如:

如果_position_是负数,就相当于传零。

See also chop() resize() left() QStringRef::truncate()

QString::unicode

[public plain  ]

const QChar * unicode() const 返回字符串的 Unicode 表示形式。在字符串被修改之前,结果一直有效。

注意:返回的字符串可能不是以‘\0’结尾。使用 size() 来确定数组的长度。

See also setUnicode() utf16() fromRawData()

QString::utf16

[public plain  ]

const ushort * utf16() const 返回一个以‘\0’结束的无符号短字符串数组的 QString 。在字符串被修改之前,结果一直有效。

返回的字符串是按主机字节顺序排列的。

See also setUtf16() unicode()

QString::vasprintf

[public plain static ]

QString vasprintf(const char *cformat, va_list ap) 相当于 asprintf() 的方法,但是使用一个va_list_ap_代替变量参数列表。关于_cformat_的解释请参见 asprintf() 文档。

本方法不调用 va_end 宏,只是负责在_ap_上调用 va_end。

See also asprintf()

QString::vsprintf

[public plain  ]

QString & vsprintf(const char *cformat, va_list ap) 使用 vasprintf()arg()QTextStream 代替。

QString::~QString

[public destructor  ]

~QString() 销毁该字符串。 这个枚举描述了Unicode文本的各种标准化形式。

QString::NormalizationForm_DNormalizationForm_D

Constant Description
QString::NormalizationForm_D 规范分解
QString::NormalizationForm_CNormalizationForm_C
Constant Description
:------- :-----
QString::NormalizationForm_C 规范分解后进行兼容性组合
QString::NormalizationForm_KDNormalizationForm_KD
Constant Description
:------- :-----
QString::NormalizationForm_KD 兼容性分解
QString::NormalizationForm_KCNormalizationForm_KC
Constant Description
:------- :-----
QString::NormalizationForm_KC 兼容性分解后进行规范组合

See also normalized() http://www.unicode.org/reports/tr15/ 这个枚举指定了一些标志,这些标志可以用来影响 section() 函数在分隔符和空字段方面的行为。

QString::SectionDefaultSectionDefault

Constant Description
QString::SectionDefault 空字段会被计算,首尾分隔符不包括在内,分隔符会根据大小写进行比较。
QString::SectionSkipEmptySectionSkipEmpty
Constant Description
:------- :-----
QString::SectionSkipEmpty 将空字段视为不存在,即就startend而言,不考虑它们。
QString::SectionIncludeLeadingSepSectionIncludeLeadingSep
Constant Description
:------- :-----
QString::SectionIncludeLeadingSep 在结果字符串中包含首部分隔符(如果有的话)。
QString::SectionIncludeTrailingSepSectionIncludeTrailingSep
Constant Description
:------- :-----
QString::SectionIncludeTrailingSep 在结果字符串中包含尾部分隔符(如果有的话)。
QString::SectionCaseInsensitiveSepsSectionCaseInsensitiveSeps
Constant Description
:------- :-----
QString::SectionCaseInsensitiveSeps 分隔符会根据大小写进行比较。

See also section() 使用 Qt::SplitBehavior 代替。

这个枚举指定了 split() 函数对空字符串的处理方式。

QString::KeepEmptyPartsKeepEmptyParts

Constant Description
QString::KeepEmptyParts 如果一个字段为空,将其保留在结果中。
QString::SkipEmptyPartsSkipEmptyParts
Constant Description
:------- :-----
QString::SkipEmptyParts 如果一个字段是为空,不将其包含在结果中。

See also split()

typedef QString::ConstIterator

Qt 风格的迭代器 QString::const_iterator

typedef QString::Data

typedef QString::DataPtr

typedef QString::Iterator

Qt 风格的迭代器 QString::iterator

typedef QString::SectionFlags

typedef QString::const_iterator

See also QString::iterator

typedef QString::const_pointer

该类型定义提供了一个指向 QString 元素( QChar )的 STL 风格指针。

typedef QString::const_reference

typedef QString::const_reverse_iterator

See also QString::reverse_iterator QString::const_iterator

typedef QString::difference_type

typedef QString::iterator

See also QString::const_iterator

typedef QString::pointer

QString::const_pointer 类型定义提供了一个指向 QString 元素( QChar )的 STL 风格指针。

typedef QString::reference

typedef QString::reverse_iterator

See also QString::const_reverse_iterator QString::iterator
s

typedef QString::size_type

typedef QString::value_type