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 *的隐式转换的风险。为了将这些风险降到最低，可以通过定义以下一些预处理器符号来关闭这些隐式转换。

QT_NO_CAST_FROM_ASCII 禁止将 C 字符串和指针自动转换为 Unicode。
QT_RESTRICTED_CAST_FROM_ASCII 允许从 C 字符和字符数组自动转换，但禁止从字符指针到 Unicode 的自动转换。
QT_NO_CAST_TO_ASCII 禁用从 QString 到 C 字符串的自动转换。

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

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

C 程序员注意事项
由于 C++ 的类型系统和QString是implicitly shared的，字符串可以像`int`或其它基本类型一样对待。例如：该`result`变量是在堆栈上分配的普通变量。当`return`被调用时，由于我们要按值返回，因此将调用复制构造函数，并返回字符串的副本。由于隐式共享，因此不会进行实际的复制。

C 程序员注意事项

由于 C++ 的类型系统和QString是implicitly 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`	使用`e`或`f`格式，以最简洁的为准
`G`	使用`E`或`f`格式，以最简洁的为准

参数格式中指定了精度。对于‘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 的考虑范围之外。

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()

[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 字符的输入是没有定义的。

QString::QString

[public constructor ]

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

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

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 警告的编译器。

暂无该属性

[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填充。

[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

首先，Hello替换了%1，所以字符串变成了"Hello%3%2"。
然后，20代替%2，这样字符串就变成了"Hello%320"。
由于最大的数字位标值是99，所以50代替了%32。

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

QString::asprintf

[public plain static ]

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

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

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

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

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

See also arg()

[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() 代替。

QString::chopped

[public plain ]

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

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

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::matchedLength ， QRegExp::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 （默认），则搜索区分大小写；否则搜索不区分大小写。

[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 简单地迭代字符串中的匹配项不同。

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() 。

[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() 一样。

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)

[public plain static ]

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

QString::fromStdU16String

[public plain static ]

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

QString::fromStdU32String

[public plain static ]

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

[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 数据进行深度复制。

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 数据进行深度复制。

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 。

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’结尾。

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 ]

[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_，并返回这个字符串的引用。

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 ]

[public plain ]

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

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

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() 。

[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_开始的所有字符。

[public plain static ]

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

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

[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 ]

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 ]

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

返回和_margins_相加的_rectangle_。

这个操作通常是非常快的（恒定时间），因为 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_追加到这个字符串上。

[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 ]

暂无该属性

[private plain ]

QDebug operator<<(QDebug , const QBitArray &)

暂无该属性

[private plain ]

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

暂无该属性

[private plain ]

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

[public plain ]

[private plain ]

QDebug operator<<(QDebug , const QFileInfo &)

[private plain ]

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

暂无该属性

[public plain ]

[public plain ]

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

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

暂无该属性

暂无该属性

[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 &)

[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 move-assign ]

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

[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。

[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 ]

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

[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 &)

[public plain ]

[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()

[public plain ]

[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 ]

[public plain ]

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

如果_cs_是 Qt::CaseSensitive （默认），则搜索区分大小写；否则搜索不区分大小写。

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

See also replace()

例子：

See also insert() remove()

QString::replace

[public plain ]

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

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

[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), ...代替。

QString::replace

[public plain ]

QString & replace(const QRegularExpression &re, const QString &after) 这个函数重载了 replace() 。

将每次出现的_re_正则表达式替换为_after_字符串，并返回对该字符串的引用。例如：

对于包含捕获组的正则表达式，在后面出现的\1，\2，...，会被相应的捕获组捕获的字符串所取代。

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，则返回整个字符串。

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，以此类推。

[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‘和‘ ‘。

下面是一个例子，使用一个或多个空白字符作为分隔符来提取句子中的单词：

下面是一个类似的例子，但这次使用任何非单词字符序列作为分隔符：

这里是第三个例子，使用零长度的断言，\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 reserve() capacity()

[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 不兼容。

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() 。

该函数忽略首尾空白符。

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() 。

例如：

该函数忽略首尾空白符。

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() 。

例如：

该函数忽略首尾空白符。

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 表示形式。

如果字符串中包含非拉丁字符，则返回的字节数组未定义。这些字符可以被抑制或用问号代替。

QString::toLatin1_helper

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() 。

例如：

该函数忽略首尾空白符。

QString::toStdString

[public plain ]

std::string toStdString() const 返回一个包含 QString 数据的 std::string 对象。使用 toUtf8() 函数将Unicode数据转换为8位字符。

这个方法主要用于传递一个 QString 到一个接受 std::string 对象的函数。

QString::toStdU16String

[public plain ]

std::u16string toStdU16String() const 返回一个包含 QString 中数据的 std::u16string 对象。Unicode 数据与 utf16() 方法返回的数据相同。

QString::toStdU32String

如果_ok_不为nullptr，则通过设置*_ok_为false来报告失败，设置*_ok_为True来报告成功。

如果_base_为0，则使用C语言惯例：如果字符串以"0x"开头，使用基数16；如果字符串以 "0"开头，使用基数8；否则，使用基数10。

字符串的转换总是发生在‘C’语言环境下。对于依赖于本地语言的转换，使用 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() 。

例如：

该函数忽略首尾空白符。

QString::toUcs4

[public plain ]

QVector toUcs4() const 返回一个 UCS-4/UTF-32 表示的 QVector 字符串。

UCS-4 是一种 Unicode 编解码器，因此它是无损的。这个字符串中的所有字符都将用 UCS-4 编码。在这个字符串中，任何无效的代码单位序列都会被 Unicode 的替换字符（ QChar::ReplacementCharacter ，对应U+FFFD）所取代。

返回的向量不是以‘\0’结束的。

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 。

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_中字符串的实际长度。

注意：这个函数不会在数组中附加一个空字符。

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_是负数，就相当于传零。

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	将空字段视为不存在，即就start和end而言，不考虑它们。
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

typedef QString::difference_type

typedef QString::iterator

See also QString::const_iterator

typedef QString::pointer

QString::const_pointer 类型定义提供了一个指向 QString 元素（ QChar ）的 STL 风格指针。

qstring_zh

Class::QString

Detailed Description

初始化字符串

处理字符串数据

查询字符串数据

比较字符串

在8位字符串和 Unicode 字符串之间进行转换。

Null 和空字符串之间的区别

参数格式

更高效的字符串构造函数

超大和内存溢出情况下

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

QString::QString

暂无该属性

暂无该属性

暂无该属性

暂无该属性

暂无该属性

QString::append

QString::append

QString::append

QString::append

QString::append

QString::append

QString::append

QString::append

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::arg

QString::asprintf

QString::at

QString::back

QString::back

QString::begin

QString::begin

QString::capacity

QString::cbegin

QString::cend

QString::chop

QString::chopped

QString::clear

QString::compare

QString::compare

QString::compare

QString::compare

QString::compare

QString::compare

QString::compare

QString::compare