QString Class

成员函数文档

[constexpr noexcept] QString::QString()

构建一个空字符串。空字符串也被视为空的。

另请参阅 isEmpty(),isNull() 以及Distinction Between Null and Empty Strings 。

QString::QString(QChar ch)

构建一个长度为 1 的字符串，其中包含字符ch 。

QString::QString(QLatin1StringView str)

构建由str 处理的Latin-1字符串的副本。

另请参阅 fromLatin1()。

[explicit, since 6.8] QString::QString(QStringView sv)

构建一个初始化为字符串视图数据的字符串。

当且仅当sv 为空时，QString才会为空。

该函数在 Qt 6.8 中引入。

另请参阅 fromUtf16()。

QString::QString(const QByteArray &ba)

构建一个由字节数组ba 初始化的字符串。给定的字节数组将通过fromUtf8()函数转换为Unicode。

您可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII 来禁用此构造函数。例如，如果您希望确保所有用户可见的字符串都经过QObject::tr()处理，此方法便十分有用。

另请参阅 fromLatin1()、fromLocal8Bit() 和fromUtf8()。

QString::QString(const char *str)

构建一个由 8 位字符串 `str` 初始化的字符串。给定的 `const char` 指针将通过 `fromUtf8()` 函数转换为 Unicode。

您可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII 来禁用此构造函数。例如，如果您希望确保所有用户可见的字符串都通过QObject::tr() 进行转换，此方法会非常有用。

另请参阅 fromLatin1()、fromLocal8Bit() 和fromUtf8()。

[since 6.1] QString::QString(const char8_t *str)

构建一个初始化为 UTF-8 字符串str 的字符串。给定的 const char8_t 指针将通过fromUtf8() 函数转换为 Unicode。

该函数在 Qt 6.1 中引入。

另请参阅 fromLatin1()、fromLocal8Bit() 和fromUtf8()。

[explicit] QString::QString(const QChar *unicode, qsizetype size = -1)

构建一个字符串，该字符串初始化为数组unicode 中前size 个字符。QChar

如果unicode 为 0，则构建一个空字符串。

如果size 为负数，则假定unicode 指向一个以 '\0' 结尾的数组，并动态确定其长度。结尾的空字符不被视为字符串的一部分。

QString 会对字符串数据进行深度复制。Unicode 数据将原样复制，如果存在字节顺序标记（BOM），则予以保留。

另请参阅 fromRawData()。

QString::QString(qsizetype size, QChar ch)

根据给定的size 构建一个字符串，其中每个字符均设置为ch 。

另请参阅 fill()。

[noexcept] QString::QString(const QString &other)

创建other 的副本。

此操作耗时为常数时间，因为 QString 是隐式共享的。这使得从函数中返回 QString 非常快。如果共享的实例被修改，它将被复制（写时复制），而这需要线性时间。

另请参阅 operator=()。

[noexcept default] QString::QString(QString &&other)

通过移动赋值构造一个 QString 实例，使其指向与 `other ` 所指向的同一对象。

[noexcept] QString::~QString()

销毁该字符串。

QString &QString::append(const QString &str)

将字符串str 追加到该字符串的末尾。

示例：

QString x = "free";
QString y = "dom";

x.append(y);
// x == "freedom"

这与使用insert() 函数的效果相同：

x.insert(x.size(), y);

append() 函数通常运行非常快（常数时间），因为QString 会在字符串数据末尾预先分配额外空间，从而使其能够动态扩展，而无需每次都重新分配整个字符串。

另请参阅 operator+=()、prepend() 和insert()。

QString &QString::append(QChar ch)

将字符ch 追加到该字符串后。

QString &QString::append(QLatin1StringView str)

将str 所处理的Latin-1字符串追加到此字符串后。

[since 6.0] QString &QString::append(QStringView v)

将给定的字符串视图v 追加到该字符串末尾，并返回结果。

该函数在 Qt 6.0 中引入。

[since 6.5] QString &QString::append(QUtf8StringView str)

将 UTF-8 字符串视图 `str ` 追加到此字符串后。

该函数自 Qt 6.5 起引入。

QString &QString::append(const QByteArray &ba)

将字节数组ba 追加到此字符串后。给定的字节数组将通过fromUtf8()函数转换为Unicode。

您可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII 来禁用此函数。例如，如果您希望确保所有用户可见的字符串都经过QObject::tr()处理，这将非常有用。

QString &QString::append(const char *str)

将字符串str 追加到该字符串末尾。给定的 const char 指针将通过fromUtf8() 函数转换为 Unicode。

您可以在编译应用程序时通过定义QT_NO_CAST_FROM_ASCII 来禁用此函数。例如，如果您希望确保所有用户可见的字符串都经过QObject::tr() 处理，此方法会很有用。

QString &QString::append(const QChar *str, qsizetype len)

将QChar 数组str 中的字符len 追加到此字符串中。

template <typename... Args> QString QString::arg(Args &&... args) const

将该字符串中所有出现的%N 替换为args 中的对应参数。这些参数不按位置排序：args 中的第一个参数将%N 替换为最小的N （所有该值），args 中的第二个参数将%N 替换为次小的N ，以此类推。

Args 可以由任何能隐式转换为QAnyStringView 的内容组成。

另请参阅 QString::arg()。

template <typename T> requires if_string_like<T> QString QString::arg(const T &a, int fieldWidth = 0, QChar fillChar = u' ') const

返回该字符串的副本，其中编号最小的占位符被替换为字符串a ，即%1 、%2 、...、%99 。

fieldWidth 指定a 应占用的最小空间。如果a 所需的空间小于fieldWidth ，则使用字符fillChar 将其补足至fieldWidth 。正值fieldWidth 将生成右对齐文本，负值fieldWidth 将生成左对齐文本。

以下示例演示了如何创建一个status 字符串，用于在处理文件列表时报告进度：

int i;                // current file's number
int total;            // number of files to process
QStringView fileName; // current file's name

QString status = QString("Processing file %1 of %2: %3")
                .arg(i).arg(total).arg(fileName);

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

与asprintf() 相比，使用 arg() 的一个优势在于：如果应用程序的字符串被翻译成其他语言，编号占位符的顺序可能会发生变化，但每个 arg() 仍会替换编号最小的未被替换的占位符，无论它出现在何处。 此外，如果字符串中出现多个编号为%i 的占位符，arg() 会将它们全部替换。

如果不再有未替换的占位符，则会打印一条警告消息，且结果未定义。占位符编号必须在 1 到 99 之间。

template <typename T> requires if_integral_non_char<T> QString QString::arg(T a, int fieldWidth = 0, int base = 10, QChar fillChar = u' ') const

a 参数采用基数base 表示，其默认值为 10，且必须在 2 到 36 之间。对于 10 以外的基数，a 将被视为无符号整数。

fieldWidth 指定将 `a ` 补齐至的最小长度，并用字符 `fillChar` 填充。正值将产生右对齐的文本；负值将产生左对齐的文本。

'%' 后面可以跟一个 'L'，在这种情况下，该序列将被替换为a 的本地化表示形式。转换使用由QLocale::setDefault() 设置的默认区域设置。如果未指定默认区域设置，则使用系统区域设置。如果base 不是 10，则忽略 'L' 标志。

QString str;
str = QString("Decimal 63 is %1 in hexadecimal")
        .arg(63, 0, 16);
// str == "Decimal 63 is 3f in hexadecimal"

QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
str = QString("%1 %L2 %L3")
        .arg(12345)
        .arg(12345)
        .arg(12345, 0, 16);
// str == "12345 12,345 3039"

另请参阅 Number formats 。

template <typename T> requires if_floating_point<T> QString QString::arg(T a, int fieldWidth = 0, char format = 'g', int precision = -1, QChar fillChar = u' ') const

参数 `a ` 将根据指定的 `format ` 和 `precision` 进行格式化。详情请参阅Floating-point Formats 。

fieldWidth 指定将 `a ` 补齐至的最小长度，并用字符 `fillChar` 填充。正值将生成右对齐文本；负值将生成左对齐文本。

double d = 12.34;
QString str = QString("delta: %1").arg(d, 0, 'E', 3);
// str == "delta: 1.234E+01"

另请参见 QLocale::toString()、QLocale::FloatingPointPrecisionOption 以及Number formats 。

[static] QString QString::asprintf(const char *cformat, ...)

根据格式字符串cformat 和一组任意的参数，安全地构建一个格式化字符串。

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

QString result;
QTextStream(&result) << "pi = " << 3.14;
// result == "pi = 3.14"

对于translations ，特别是当字符串中包含多个转义序列时，应考虑改用arg() 函数。这样可以由翻译人员控制替换的顺序。

另请参阅 arg()。

[since 6.6] QString &QString::assign(QAnyStringView v)

将该字符串的内容替换为v 的副本，并返回该字符串的引用。

该字符串的大小将等于v 的大小，并被转换为 UTF-16 编码，如同通过v.toString() 处理一般。不过，与QAnyStringView::toString() 不同，此函数仅在估计大小超过该字符串的容量或该字符串为共享字符串时才分配内存。

该函数在 Qt 6.6 中引入。

另请参阅 QAnyStringView::toString()。

[since 6.6] template <typename InputIterator> requires if_compatible_iterator<InputIterator> QString &QString::assign(InputIterator first, InputIterator last)

将该字符串的内容替换为迭代器范围 [first,last) 中元素的副本，并返回对该字符串的引用。

该字符串的大小将等于范围 [first,last) 中元素的解码长度，这并不一定与范围本身的长度相同，因为该函数会将输入字符集透明地重新编码为 UTF-16。

只有当范围中的元素个数（对于非 UTF-16 编码的输入，则是结果字符串的最大可能大小）超过该字符串的容量，或者该字符串是共享的，此函数才会分配内存。

约束

仅当InputIterator 满足LegacyInputIterator的要求，且InputIterator 的value_type 属于以下字符类型之一时，才参与重载解析：

• QChar
• QLatin1Char
• char
• unsigned char
• signed char
• char8_t
• char16_t
• （在 Windows 等平台上，该类型为 16 位类型）wchar_t
• char32_t

该函数在 Qt 6.6 中引入。

[since 6.6] QString &QString::assign(qsizetype n, QChar c)

将该字符串的内容替换为n 个c 的副本，并返回该字符串的引用。

该字符串的大小将等于n ，该值必须为非负数。

只有当n 超过该字符串的容量或该字符串是共享的时，此函数才会分配内存。

该函数在 Qt 6.6 中引入。

另请参阅 fill()。

const QChar QString::at(qsizetype position) const

返回字符串中位于指定索引位置position 处的字符。

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

另请参阅 operator[]()。

QChar &QString::back()

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

提供此函数是为了兼容 STL。

另请参阅 front()、at() 和operator[]()。

QChar QString::back() const

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

提供此函数是为了与 STL 兼容。

另请参见 front()、at() 和operator[]()。

QString::iterator QString::begin()

返回一个指向字符串中第一个字符的STL 风格迭代器。

另请参阅 constBegin() 和end()。

QString::const_iterator QString::begin() const

qsizetype QString::capacity() const

返回字符串中可存储的最大字符数，且不会强制进行内存重新分配。

此函数的唯一目的是为精细调整QString 的内存使用提供一种手段。通常情况下，您几乎不需要调用此函数。若要了解字符串中包含多少个字符，请调用size()。

另请参阅 reserve() 和squeeze()。

QString::const_iterator QString::cbegin() const

返回一个指向字符串中第一个字符的常量STL 风格迭代器。

另请参阅 begin() 和cend()。

QString::const_iterator QString::cend() const

返回一个指向字符串中最后一个字符之后位置的常量STL 风格迭代器。

另请参阅 cbegin() 和end()。

void QString::chop(qsizetype n)

从字符串末尾删除n 个字符。

如果n 大于或等于size()，则结果为空字符串；如果n 为负数，则等同于传入零。

示例：

QString str("LOGOUT\r\n");
str.chop(2);
// str == "LOGOUT"

若要从字符串开头移除字符，请改用remove()。

另请参阅 truncate()、resize()、remove() 和QStringView::chop()。

返回一个字符串，其中包含该字符串最左侧的size() -len 个字符。

另请参阅 endsWith()、first()、last()、sliced()、chop()、truncate() 和slice()。

void QString::clear()

清空字符串的内容并将其设为空。

另请参阅 resize() 和isNull()。

[static noexcept] int QString::compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将字符串s1 与字符串s2 进行比较，如果s1 小于s2 ，则返回负整数；如果大于s2 ，则返回正整数；如果两者相等，则返回零。

如果cs 设置为Qt::CaseSensitive （默认值），则比较区分大小写；否则，比较不区分大小写。

区分大小写的比较完全基于字符的 Unicode 数值，速度非常快，但这并非人类所期望的结果。请考虑使用localeAwareCompare() 对用户可见的字符串进行排序。

int x = QString::compare("aUtO", "AuTo", Qt::CaseInsensitive);  // x == 0
int y = QString::compare("auto", "Car", Qt::CaseSensitive);     // y > 0
int z = QString::compare("auto", "Car", Qt::CaseInsensitive);   // z < 0

另请参阅 operator==()、operator<()、operator>() 以及Comparing Strings 。

[noexcept] int QString::compare(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

使用大小写敏感设置cs ，将此内容与ch 进行比较。

[noexcept] int QString::compare(QLatin1StringView other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

与 compare(*this,other,cs) 相同。

[noexcept] int QString::compare(QStringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

使用大小写敏感设置cs ，将此内容与s 进行比较。

[noexcept] int QString::compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

按字典顺序将该字符串与字符串other 进行比较，若该字符串小于other ，则返回一个负整数；若大于other ，则返回一个正整数；若两者相等，则返回零。

与 compare(*this,other,cs) 相同。

[static noexcept] int QString::compare(QLatin1StringView s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

使用大小写敏感设置cs 对s1 和s2 进行比较。

[static noexcept] int QString::compare(QStringView s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

[static noexcept] int QString::compare(const QString &s1, QLatin1StringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

使用大小写敏感设置cs ，对s1 和s2 进行比较。

[static noexcept] int QString::compare(const QString &s1, QStringView s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)

QString::const_iterator QString::constBegin() const

返回一个指向字符串中第一个字符的 constSTL 风格迭代器。

另请参阅 begin() 和constEnd()。

const QChar *QString::constData() const

返回指向QString 中存储的数据的指针。该指针可用于访问构成该字符串的字符。

请注意，该指针仅在字符串未被修改时才有效。

另请参阅 data()、operator[]() 和fromRawData()。

QString::const_iterator QString::constEnd() const

返回一个指向字符串中最后一个字符之后位置的常量STL 风格迭代器。

另请参阅 constBegin() 和end()。

bool QString::contains(const QRegularExpression &re, QRegularExpressionMatch *rmatch = nullptr) const

如果正则表达式 `re ` 与该字符串中的某处匹配，则返回 `true `；否则返回 `false`。

如果匹配成功，且 `rmatch ` 不是 `nullptr`，它还会将匹配结果写入由 `rmatch` 所指向的 `QRegularExpressionMatch ` 对象中。

另请参阅 QRegularExpression::match()。

bool QString::contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

如果该字符串中包含字符串str ，则返回true ；否则返回false 。

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

示例：

QString str = "Peter Pan";
str.contains("peter", Qt::CaseInsensitive);    // returns true

另请参阅 indexOf() 和count()。

bool QString::contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

如果该字符串中包含字符ch ，则返回true ；否则返回false 。

bool QString::contains(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

如果该字符串中包含 latin-1 字符串str ，则返回true ；否则返回false 。

[noexcept] bool QString::contains(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

如果该字符串中包含字符串视图str ，则返回true ；否则返回false 。

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

另请参阅 indexOf() 和count()。

qsizetype QString::count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回该字符串中字符串str 的出现次数（可能存在重叠）。

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

另请参阅 contains() 和indexOf()。

qsizetype QString::count(const QRegularExpression &re) const

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

出于历史原因，此函数会统计重叠的匹配，因此在下例中，“ana”或“ama”共出现四次：

QString str = "banana and panama";
str.count(QRegularExpression("a[nm]a"));    // returns 4

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

另请参阅 QRegularExpression::globalMatch()。

qsizetype QString::count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符ch 在字符串中的出现次数。

如果 `cs ` 为 `Qt::CaseSensitive `（默认值），则搜索区分大小写；否则，搜索不区分大小写。

另请参阅 contains() 和indexOf()。

[since 6.0] qsizetype QString::count(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回该字符串中字符串视图str 的出现次数（可能包含重叠）。

如果 `cs ` 为 `Qt::CaseSensitive `（默认值），则搜索区分大小写；否则，搜索不区分大小写。

该函数在 Qt 6.0 中引入。

另请参阅 contains() 和indexOf()。

QString::const_reverse_iterator QString::crbegin() const

返回一个指向字符串中第一个字符（按反向顺序）的常量STL 风格反向迭代器。

另请参阅 begin()、rbegin() 和rend()。

QString::const_reverse_iterator QString::crend() const

返回一个常量STL 风格的反向迭代器，该迭代器指向字符串中最后一个字符之后的第一个位置，且按反向顺序排列。

另请参阅 end()、rend() 和rbegin()。

QChar *QString::data()

返回指向QString 中存储的数据的指针。该指针可用于访问和修改构成该字符串的字符。

与constData()和unicode()不同，返回的数据始终以'\0'结尾。

示例：

QString str= "Hello world";
QChar*data =str.data();
while(!data->isNull()) {
    qDebug() << data->unicode();
   ++data;
}

请注意，该指针仅在字符串未通过其他方式被修改的情况下才保持有效。对于只读访问，constData() 的执行速度更快，因为它绝不会引发深度拷贝。

另请参阅 constData() 和operator[]()。

const QChar *QString::data() const

另请参阅 fromRawData()。

void QString::detach()

确保该字符串的数据不再与其他实例共享。

QString::iterator QString::end()

返回一个STL 风格的迭代器，该迭代器指向字符串中最后一个字符之后的第一个位置。

另请参阅 begin() 和constEnd()。

QString::const_iterator QString::end() const

bool QString::endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

如果字符串以s 结尾，则返回true ；否则返回false 。

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

QString str = "Bananas";
str.endsWith("anas");         // returns true
str.endsWith("pple");         // returns false

另请参阅 startsWith()。

bool QString::endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

如果字符串以“c ”结尾，则返回true ；否则返回false 。

bool QString::endsWith(QLatin1StringView s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

[noexcept] bool QString::endsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

如果字符串以字符串视图str 结尾，则返回true ；否则返回false 。

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

另请参阅 startsWith()。

[since 6.1] QString::iterator QString::erase(QString::const_iterator first, QString::const_iterator last)

从字符串中移除半开放区间 [first,last ) 内的字符。返回一个迭代器，该迭代器指向最后一个被删除字符之后的字符（即删除操作发生前由last 所指向的字符）。

该函数于 Qt 6.1 中引入。

[since 6.5] QString::iterator QString::erase(QString::const_iterator it)

从字符串中删除由it 表示的字符。返回指向被删除字符之后紧邻的字符的迭代器。

QString c = "abcdefg";
auto it = c.erase(c.cbegin()); // c is now "bcdefg"; "it" points to "b"

该函数于 Qt 6.5 中引入。

QString &QString::fill(QChar ch, qsizetype size = -1)

将字符串中的每个字符设置为字符ch 。如果size 不等于-1（默认值），则会预先将字符串调整为size 的大小。

示例：

QString str = "Berlin";
str.fill('z');
// str == "zzzzzz"

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

另请参阅 resize()。

返回一个字符串，其中包含该字符串的前n 个字符（即从该字符串开头起，直到索引位置为n 的元素处，但不包括该元素本身）。

QString x = "Pineapple";
QString y = x.first(4);      // y == "Pine"

这些函数在 Qt 6.0 中引入。

另请参见 last()、sliced()、startsWith()、chopped()、chop()、truncate(）以及slice()。

[static] QString QString::fromCFString(CFStringRef string)

创建一个新的QString ，其中包含string 中CFString的副本。

[static, since 6.6] QString QString::fromEcmaString(emscripten::val jsString)

将ECMAScript 字符串 jsString 转换为QString 。如果提供的参数不是字符串，则行为未定义。

该函数在 Qt 6.6 中引入。

另请参阅 toEcmaString()。

[static] QString QString::fromLatin1(const char *str, qsizetype size)

返回一个QString ，该对象使用拉丁-1字符串str 的前size 个字符进行初始化。

如果size 为-1 ，则改用strlen(str) 。

另请参阅 toLatin1()、fromUtf8() 和fromLocal8Bit()。

[static, since 6.0] QString QString::fromLatin1(QByteArrayView str)

返回一个用 Latin-1 字符串str 初始化的QString 。

该函数在 Qt 6.0 中引入。

[static] QString QString::fromLatin1(const QByteArray &str)

返回一个用 Latin-1 字符串str 初始化的QString 。

[static] QString QString::fromLocal8Bit(const char *str, qsizetype size)

返回一个QString ，该对象使用8位字符串str 的前size 个字符进行初始化。

如果size 的值为-1 ，则改用strlen(str) 。

在 Unix 系统上，这等同于fromUtf8()。请注意，在 Apple 系统上，此函数不会考虑NSString.defaultCStringEncoding或CFStringGetSystemEncoding()，因为这些函数通常返回旧式的“Western (Mac OS Roman)”编码，而该编码不应在现代 Apple 操作系统上使用。 在 Windows 系统上，将使用系统当前的代码页。

另请参阅 toLocal8Bit()、fromLatin1() 和fromUtf8()。

[static, since 6.0] QString QString::fromLocal8Bit(QByteArrayView str)

返回一个使用 8 位字符串str 初始化的 `QString `。

在 Unix 系统上，这等同于fromUtf8()。请注意，在 Apple 系统上，此函数不会考虑NSString.defaultCStringEncoding或CFStringGetSystemEncoding()的返回值，因为这些函数通常会返回旧式的“Western (Mac OS Roman)”编码，而该编码不应在现代 Apple 操作系统上使用。 在 Windows 上，将使用系统当前的代码页。

该函数在 Qt 6.0 中引入。

[static] QString QString::fromLocal8Bit(const QByteArray &str)

返回一个使用 8 位字符串str 初始化的 `QString `。

在 Unix 系统上，这等同于fromUtf8()。请注意，在 Apple 系统上，此函数不会考虑NSString.defaultCStringEncoding或CFStringGetSystemEncoding()的返回值，因为这些函数通常会返回旧式的“Western (Mac OS Roman)”编码，而该编码在现代 Apple 操作系统上不应使用。 在 Windows 上，将使用系统当前的代码页。

[static] QString QString::fromNSString(const NSString *string)

创建一个新的QString ，其中包含string NSString的副本。

[static, since 6.10] QString QString::fromRawData(const char16_t *unicode, qsizetype size)

构建一个QString ，该对象使用数组unicode 中的前size 个Unicode字符。unicode 中的数据不会被复制。调用方必须能够保证，只要QString （或其未被修改的副本）存在，unicode 就不会被删除或修改。

任何试图修改QString 或其副本的行为，都会导致系统创建数据的深拷贝，从而确保原始数据不会被修改。

以下是一个示例，展示了如何在内存中对原始数据使用QRegularExpression ，而无需将数据复制到QString 中：

QRegularExpression pattern("\u00A4");
static const char16_t unicode[] = {
        0x005A, 0x007F, 0x00A4, 0x0060,
        0x1009, 0x0020, 0x0020};

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

该函数在 Qt 6.10 中引入。

另请参阅 fromUtf16()、setRawData()、data()、constData()、nullTerminate() 以及nullTerminated()。

[static] QString QString::fromRawData(const QChar *unicode, qsizetype size)

[static] QString QString::fromStdString(const std::string &str)

返回str 字符串的副本。该字符串默认采用UTF-8编码，并将通过fromUtf8()函数转换为QString 格式。

另请参阅 fromLatin1()、fromLocal8Bit()、fromUtf8() 以及QByteArray::fromStdString()。

[static] QString QString::fromStdU16String(const std::u16string &str)

返回str 字符串的副本。假定给定的字符串采用UTF-16编码，并使用fromUtf16()函数将其转换为QString 。

另请参阅 fromUtf16()、fromStdWString() 和fromStdU32String()。

[static] QString QString::fromStdU32String(const std::u32string &str)

返回str 字符串的副本。假定给定的字符串采用UTF-32编码，并使用fromUcs4()函数将其转换为QString 。

另请参阅 fromUcs4()、fromStdWString()，以及fromStdU16String()。

[static] QString QString::fromStdWString(const std::wstring &str)

返回字符串str 的副本。如果 wchar_t 的大小为 2 字节（例如在 Windows 上），则假定给定的字符串采用 utf16 编码；如果 wchar_t 的大小为 4 字节（大多数 Unix 系统），则假定采用 ucs4 编码。

另请参阅 fromUtf16()、fromLatin1()、fromLocal8Bit()、fromUtf8()、fromUcs4()、fromStdU16String(）以及fromStdU32String()。

[static] QString QString::fromUcs4(const char32_t *unicode, qsizetype size = -1)

返回一个QString ，该对象使用Unicode字符串unicode （以UTF-32编码）的前size 个字符进行初始化。

如果size 为 -1（默认值），则unicode 必须以 '\0' 结尾。

另请参阅 toUcs4()、fromUtf16()、utf16()、setUtf16()、fromWCharArray()，以及fromStdU32String()。

[static] QString QString::fromUtf8(const char *str, qsizetype size)

返回一个使用 UTF-8 字符串str 的前size 字节初始化的 `QString ` 对象。

如果size 为-1 ，则改用strlen(str) 。

UTF-8 是一种 Unicode 编码，可以表示 Unicode 字符串（如QString ）中的所有字符。但是，UTF-8 中可能会出现无效序列，如果发现此类序列，它们将被一个或多个“替换字符”替换，或者被抑制。 这些包括非 Unicode 序列、非字符、过长序列或编码为 UTF-8 的代理码点。

只要所有 UTF-8 字符都在传入数据中被正确终止，即可使用此函数对传入数据进行增量处理。字符串末尾的任何未终止字符都将被替换或忽略。若要进行带状态的解码，请使用QStringDecoder 。

另请参阅 toUtf8()、fromLatin1() 和fromLocal8Bit()。

[static, since 6.0] QString QString::fromUtf8(QByteArrayView str)

返回一个用 UTF-8 字符串str 初始化的QString 对象。

该函数在 Qt 6.0 中引入。

[static] QString QString::fromUtf8(const QByteArray &str)

返回一个用 UTF-8 字符串str 初始化的QString 对象。

[static, since 6.1] QString QString::fromUtf8(const char8_t *str)

此重载仅在以 C++20 模式编译时可用。

该函数在 Qt 6.1 中引入。

[static, since 6.0] QString QString::fromUtf8(const char8_t *str, qsizetype size)

此重载仅在以 C++20 模式编译时可用。

该函数在 Qt 6.0 中引入。

[static] QString QString::fromUtf16(const char16_t *unicode, qsizetype size = -1)

返回一个QString ，其初始化值为Unicode字符串unicode （采用ISO-10646-UTF-16编码）的前size 个字符。

如果size 为 -1（默认值），则unicode 必须以 '\0' 结尾。

该函数会检查字节顺序标记（BOM）。如果缺失，则假定为宿主字节顺序。

与其他 Unicode 转换相比，此函数速度较慢。如果可能，请使用QString(constQChar *, qsizetype) 或QString(constQChar *)。

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

另请参阅 utf16()、setUtf16() 和fromStdU16String()。

[static] QString QString::fromWCharArray(const wchar_t *string, qsizetype size = -1)

读取由string 指向的wchar_t 数组中的前size 个代码单元，将其转换为Unicode，并将结果作为QString 返回。如果该类型的大小为4字节，则假定wchar_t 使用的编码为UTF-32；如果其大小为2字节，则假定为UTF-16。

如果size 为 -1（默认值），则string 必须以 '\0' 结尾。

另请参阅 fromUtf16()、fromLatin1()、fromLocal8Bit()、fromUtf8()、fromUcs4() 以及fromStdWString()。

QChar &QString::front()

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

提供此函数是为了兼容 STL。

另请参阅 back()、at() 和operator[]()。

QChar QString::front() const

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

提供此函数是为了兼容 STL。

另请参见 back()、at() 和operator[]()。

qsizetype QString::indexOf(QLatin1StringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回该字符串中由 `str ` 解析的 Latin-1 字符串首次出现的位置索引，从索引位置 `from` 开始向前搜索。若未找到 `str `，则返回 -1。

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

示例：

QString x = "sticky question";
QString y = "sti";
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

如果from 为 -1，则从最后一个字符开始搜索；如果为 -2，则从倒数第二个字符开始，依此类推。

另请参阅 lastIndexOf()、contains() 和count()。

qsizetype QString::indexOf(const QRegularExpression &re, qsizetype from = 0, QRegularExpressionMatch *rmatch = nullptr) const

返回正则表达式re 在字符串中首次匹配的索引位置，从索引位置from 开始向前搜索。如果re 没有任何匹配，则返回 -1。

如果匹配成功，且rmatch 并非nullptr ，则还会将匹配结果写入由rmatch 指向的QRegularExpressionMatch 对象中。

示例：

QString str = "the minimum";
str.indexOf(QRegularExpression("m[aeiou]"), 0);       // returns 4

QRegularExpressionMatch match;
str.indexOf(QRegularExpression("m[aeiou]"), 0, &match);       // returns 4
// match.captured() == mi

qsizetype QString::indexOf(const QString &str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符串中首次出现“str ”的索引位置，从索引位置from 开始向前搜索。如果未找到str ，则返回-1。

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

示例：

QString x = "sticky question";
QString y = "sti";
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

如果from 为 -1，则从最后一个字符开始搜索；如果为 -2，则从倒数第二个字符开始，依此类推。

另请参阅 lastIndexOf()、contains() 和count()。

qsizetype QString::indexOf(QChar ch, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符ch 在此字符串中首次出现的位置索引，从索引位置from 开始向前搜索。如果未找到ch ，则返回-1。

[noexcept] qsizetype QString::indexOf(QStringView str, qsizetype from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符串中首次出现字符串视图str 的索引位置，从索引位置from 开始向前搜索。如果未找到str ，则返回 -1。

如果cs 等于Qt::CaseSensitive （默认值），则搜索区分大小写；否则，搜索不区分大小写。

如果from 为 -1，则从最后一个字符开始搜索；如果为 -2，则从倒数第二个字符开始，以此类推。

另请参阅 QStringView::indexOf()、lastIndexOf()、contains() 和count()。

QString &QString::insert(qsizetype position, const QString &str)

在给定索引position 处插入字符串str ，并返回该字符串的引用。

示例：

QString str = "Meal";
str.insert(1, QString("ontr"));
// str == "Montreal"

该字符串会自动扩展以容纳插入内容。如果position 超出了字符串末尾，则会在字符串末尾追加空格字符以达到该position 位置，随后再追加str 。

另请参阅 append()、prepend()、replace() 以及remove()。

QString &QString::insert(qsizetype position, QChar ch)

在字符串中指定索引位置position 处插入ch 。

该字符串会自动扩展以容纳插入内容。如果 `position ` 超出了字符串末尾，则会在字符串末尾追加空格字符直至达到该索引 `position`，随后再插入 `ch`。

QString &QString::insert(qsizetype position, QLatin1StringView str)

将由str 处理的 Latin-1 字符串插入到指定索引位置position 。

该字符串会自动扩展以容纳插入的内容。如果position 超出了字符串末尾，则会在字符串末尾追加空格字符直至达到该position 位置，随后再追加str 。

[since 6.0] QString &QString::insert(qsizetype position, QStringView str)

在给定的索引position 处插入字符串视图str ，并返回该字符串的引用。

该字符串会自动扩展以容纳插入的内容。如果 `position ` 超出了字符串的末尾，则会在字符串后附加空格字符以达到该索引 `position`，随后再附加 `str`。

该函数在 Qt 6.0 中引入。

[since 6.5] QString &QString::insert(qsizetype position, QUtf8StringView str)

将 UTF-8 字符串视图str 插入到给定索引position 处。

该字符串会扩展以容纳插入的内容。如果position 超出了字符串的末尾，则会在字符串后追加空格字符以达到该position ，随后是str 。

该函数在 Qt 6.5 中引入。

QString &QString::insert(qsizetype position, const QByteArray &str)

将str 的内容解释为UTF-8，将其编码的Unicode字符串插入到指定索引position 处，并返回该字符串的引用。

该字符串会自动扩展以容纳插入的内容。如果position 超出了字符串的末尾，则会在字符串末尾追加空格字符以达到该position 位置，随后再追加str 。

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

QString &QString::insert(qsizetype position, const char *str)

在给定索引position 处插入C字符串str ，并返回该字符串的引用。

该字符串会自动扩展以容纳插入的内容。如果position 超出了字符串的末尾，则会在字符串末尾追加空格字符以达到该position 位置，随后再追加str 。

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

QString &QString::insert(qsizetype position, const QChar *unicode, qsizetype size)

将QChar 数组unicode 中的前size 个字符插入到字符串中给定的索引position 处。

该字符串会自动扩展以容纳插入的内容。如果position 超出了字符串的末尾，则会在字符串末尾追加空格字符以达到该position ，随后插入QChar 数组unicode 中的size 个字符。

[constexpr noexcept] bool QString::isEmpty() const

如果字符串中没有字符，则返回true ；否则返回false 。

示例：

QString().isEmpty();            // returns true
QString("").isEmpty();          // returns true
QString("x").isEmpty();         // returns false
QString("abc").isEmpty();       // returns false

另请参阅 size()。

bool QString::isLower() const

如果字符串为小写，即与toLower()折叠结果完全相同，则返回true 。

请注意，这并不意味着该字符串不包含大写字母（某些大写字母没有小写折叠形式；它们在调用toLower() 时保持不变）。有关更多信息，请参阅 Unicode 标准第 3.13 节。

另请参阅 QChar::toLower() 和isUpper()。

[constexpr] bool QString::isNull() const

如果该字符串为空，则返回true ；否则返回false 。

示例：

QString().isNull();             // returns true
QString("").isNull();           // returns false
QString("abc").isNull();        // returns false

出于历史原因，Qt 将空字符串与 null 字符串区分开来。对于大多数应用程序而言，关键在于字符串是否包含任何数据，这可以通过调用isEmpty() 函数来判断。

另请参阅 isEmpty()。

bool QString::isRightToLeft() const

如果字符串是从右向左阅读的，则返回true 。

另请参阅 QStringView::isRightToLeft()。

bool QString::isUpper() const

如果字符串为大写，即与该字符串的toUpper() 折叠结果完全相同，则返回true 。

请注意，这并不意味着该字符串不包含小写字母（某些小写字母没有大写折叠形式；它们在调用toUpper() 时保持不变）。有关更多信息，请参阅 Unicode 标准第 3.13 节。

另请参阅 QChar::toUpper() 和isLower()。

[noexcept] bool QString::isValidUtf16() const

如果字符串包含有效的 UTF-16 编码数据，则返回 `true `；否则返回 `false `。

请注意，此函数不会对数据进行任何特殊验证；它仅检查数据是否能从 UTF-16 编码中成功解码。数据被假定为采用主机字节序；BOM 的存在不影响结果。

另请参阅 QStringView::isValidUtf16()。

返回包含该字符串末尾n 个字符的字符串。

QString x = "Pineapple";
QString y = x.last(5);      // y == "apple"

这些函数在 Qt 6.0 中引入。

另请参阅 first()、sliced()、endsWith()、chopped()、chop()、truncate() 以及slice()。

qsizetype QString::lastIndexOf(const QRegularExpression &re, qsizetype from, QRegularExpressionMatch *rmatch = nullptr) const

返回正则表达式re 在字符串中最后一次匹配的索引位置，该匹配始于索引位置from 之前。

如果from 为 -1，则从最后一个字符开始搜索；如果为 -2，则从倒数第二个字符开始，以此类推。

如果re 在任何位置均未匹配，则返回 -1。

如果匹配成功且rmatch 不等于nullptr ，则还会将匹配结果写入由rmatch 指向的QRegularExpressionMatch 对象中。

示例：

QString str = "the minimum";
str.lastIndexOf(QRegularExpression("m[aeiou]"));      // returns 8

QRegularExpressionMatch match;
str.lastIndexOf(QRegularExpression("m[aeiou]"), -1, &match);      // returns 8
// match.captured() == mu

qsizetype QString::lastIndexOf(const QString &str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符串str 在本字符串中最后一次出现的索引位置，从索引位置from 开始向后搜索。

如果from 为 -1，则从字符串末尾开始搜索；如果为 -2，则从倒数第二个字符开始搜索，以此类推。

如果未找到str ，则返回 -1。

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

示例：

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

另请参阅 indexOf()、contains() 和count()。

[noexcept, since 6.3] qsizetype QString::lastIndexOf(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

该函数在 Qt 6.3 中引入。

[since 6.2] qsizetype QString::lastIndexOf(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符串str 在该字符串中最后一次出现的索引位置。如果未找到str ，则返回 -1。

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

示例：

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

该函数在 Qt 6.2 中引入。

另请参阅 indexOf()、contains() 和count()。

[noexcept, since 6.2] qsizetype QString::lastIndexOf(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符串中字符串视图str 的最后一次出现位置。如果未找到str ，则返回 -1。

如果cs 等于Qt::CaseSensitive （默认值），则搜索区分大小写；否则，搜索不区分大小写。

该函数在 Qt 6.2 中引入。

另请参见 indexOf()、contains() 和count()。

[since 6.2] qsizetype QString::lastIndexOf(const QRegularExpression &re, QRegularExpressionMatch *rmatch = nullptr) const

返回正则表达式re 在字符串中最后一次匹配的索引位置。如果re 在字符串中未匹配到任何位置，则返回 -1。

如果匹配成功且 `rmatch ` 不是 `nullptr`，它还会将匹配结果写入由 `rmatch` 指向的 `QRegularExpressionMatch ` 对象中。

示例：

QString str = "the minimum";
str.lastIndexOf(QRegularExpression("m[aeiou]"));      // returns 8

QRegularExpressionMatch match;
str.lastIndexOf(QRegularExpression("m[aeiou]"), -1, &match);      // returns 8
// match.captured() == mu

该函数于 Qt 6.2 中引入。

[since 6.2] qsizetype QString::lastIndexOf(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符串中“str ”最后一次出现的索引位置。如果未找到“str ”，则返回-1。

如果cs 等于Qt::CaseSensitive （默认值），则搜索区分大小写；否则，搜索不区分大小写。

示例：

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

该函数在 Qt 6.2 中引入。

另请参阅 indexOf()、contains() 和count()。

qsizetype QString::lastIndexOf(QChar ch, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符ch 在此字符串中最后一次出现的索引位置，从索引位置from 开始向后搜索。

qsizetype QString::lastIndexOf(QLatin1StringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回str 在此字符串中识别到的Latin-1字符串最后一次出现的索引位置，从索引位置from 开始向后搜索。

如果 `from ` 为 -1，则从最后一个字符开始搜索；如果为 -2，则从倒数第二个字符开始搜索，以此类推。

如果未找到 `str `，则返回 -1。

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

示例：

QString x = "crazy azimuths";
QString y = "az";
x.lastIndexOf(y);           // returns 6
x.lastIndexOf(y, 6);        // returns 6
x.lastIndexOf(y, 5);        // returns 2
x.lastIndexOf(y, 1);        // returns -1

另请参阅 indexOf()、contains() 和count()。

[noexcept] qsizetype QString::lastIndexOf(QStringView str, qsizetype from, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

返回字符串中字符串视图str 最后一次出现的位置索引，从索引位置from 开始向后搜索。

如果from 为 -1，则从最后一个字符开始搜索；如果为 -2，则从倒数第二个字符开始搜索，以此类推。

如果未找到str ，则返回 -1。

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

另请参阅 indexOf()、contains() 和count()。

返回一个子字符串，其中包含该字符串最左侧的n 个字符（即从该字符串开头开始，直到索引位置n 处的元素之前，但不包括该元素）。

如果已知n 不会超出范围，请在新代码中改用first()，因为它的执行速度更快。

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

另请参阅 first()、last()、startsWith()、chopped()、chop() 以及truncate()。

QString QString::leftJustified(qsizetype width, QChar fill = u' ', bool truncate = false) const

返回一个长度为width 的字符串，其中包含该字符串，并在前后用fill 字符进行填充。

如果truncate 为false ，且该字符串的size() 值大于width ，则返回的字符串是该字符串的副本。

QString s = "apple";
QString t = s.leftJustified(8, '.');    // t == "apple..."

如果 `truncate ` 为 `true `，且该字符串的 `size()` 值大于 `width`，则字符串副本中位置 `width ` 之后的所有字符将被删除，并返回该副本。

QString str = "Pineapple";
str = str.leftJustified(5, '.', true);    // str == "Pinea"

另请参阅 rightJustified()。

[constexpr noexcept] qsizetype QString::length() const

返回该字符串中的字符数。等同于 `size()`。

另请参阅 resize()。

[static] int QString::localeAwareCompare(const QString &s1, const QString &s2)

比较s1 与s2 ，并返回一个小于、等于或大于零的整数，分别表示s1 小于、等于或大于s2 。

该比较操作既取决于区域设置，也取决于平台。使用此函数可向用户呈现按顺序排序的字符串列表。

另请参阅 compare()、QLocale 以及Comparing Strings 。

[since 6.0] int QString::localeAwareCompare(QStringView other) const

将该字符串与other 字符串进行比较，并根据该字符串是否小于、等于或大于other 字符串，返回小于、等于或大于零的整数。

比较操作的方式取决于区域设置和平台。使用此函数可向用户展示按顺序排列的字符串列表。

与localeAwareCompare(*this, other) 相同。

该函数在 Qt 6.0 中引入。

另请参阅 Comparing Strings 。

int QString::localeAwareCompare(const QString &other) const

将该字符串与other 字符串进行比较，并返回一个小于、等于或大于零的整数，分别表示该字符串小于、等于或大于other 字符串。

比较操作取决于区域设置和平台。使用此函数可向用户展示按顺序排列的字符串列表。

与localeAwareCompare(*this, other) 相同。

另请参阅 Comparing Strings 。

[static, since 6.0] int QString::localeAwareCompare(QStringView s1, QStringView s2)

比较s1 与s2 ，并返回一个小于、等于或大于零的整数，分别表示s1 小于、等于或大于s2 。

该比较操作既取决于区域设置，也取决于平台。使用此函数可向用户呈现按顺序排列的字符串列表。

该函数在 Qt 6.0 中引入。

另请参阅 Comparing Strings 。

该函数返回字符串理论上可容纳的元素最大数量。实际上，该数量可能要小得多，具体取决于系统可用的内存大小。

这些函数是在 Qt 6.8 中引入的。

n 返回一个字符串，其中包含该字符串中从指定position 索引位置开始、直至（但不包括）索引位置 position + n。

如果您确定position 和n 不会超出范围，请在新代码中改用sliced()，因为它的执行速度更快。

如果position 索引超出字符串的长度，则返回空字符串。如果从给定的position 开始，字符串中可用的字符少于n 个，或者如果n 为 -1（默认值），则该函数返回从指定的position 开始的所有可用字符。

另请参阅 first()、last()、sliced()、chopped()、chop()、truncate() 和slice()。

QString QString::normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version = QChar::Unicode_Unassigned) const

根据Unicode标准中给定的version ，返回采用给定Unicode规范化方式mode 处理后的字符串。

[since 6.10] QString &QString::nullTerminate()

如果该字符串数据未以空字符结尾，则该方法将对数据进行深度复制，并使其以空字符结尾。

QString 默认是空终止的，但在某些情况下（例如使用fromRawData() 时），字符串数据并不一定以\0 字符结尾，这在调用期望接收空终止字符串的方法时可能会造成问题。

该函数于 Qt 6.10 中引入。

另请参阅 nullTerminated()、fromRawData() 和setRawData()。

返回该字符串的一个副本，该副本始终以空字符结尾。

这些函数在 Qt 6.10 中引入。

另请参阅 nullTerminate()、fromRawData() 和setRawData()。

[static] QString QString::number(long n, int base = 10)

根据指定的base ，返回与数字n 等价的字符串。

默认进制为 10，且必须在 2 到 36 之间。对于 10 以外的进制，n 将被视为无符号整数。

格式化始终使用QLocale::C ，即 English/UnitedStates。若要获取数字的本地化字符串表示形式，请使用QLocale::toString()并指定相应的区域设置。

long a = 63;
QString s = QString::number(a, 16);             // s == "3f"
QString t = QString::number(a, 16).toUpper();     // t == "3F"

另请参阅 setNum()。

[static] QString QString::number(double n, char format = 'g', int precision = 6)

返回一个字符串，该字符串表示浮点数n 。

返回一个字符串，该字符串表示n ，并根据指定的format 和precision 进行格式化。

对于包含指数的格式，指数将显示其正负号并至少包含两位数，必要时在指数左侧用零补零。

另请参阅 setNum()、QLocale::toString()、QLocale::FloatingPointPrecisionOption 以及Number formats 。

[static] QString QString::number(int n, int base = 10)

[static] QString QString::number(qlonglong n, int base = 10)

[static] QString QString::number(qulonglong n, int base = 10)

[static] QString QString::number(uint n, int base = 10)

[static] QString QString::number(ulong n, int base = 10)

QString &QString::prepend(const QString &str)

将字符串str 追加到该字符串的开头，并返回该字符串的引用。

该操作通常非常快（常数时间），因为QString 会在字符串数据的开头预分配额外空间，因此字符串可以动态扩展，而无需每次都重新分配整个字符串。

示例：

QString x = "ship";
QString y = "air";
x.prepend(y);
// x == "airship"

另请参阅 append() 和insert()。

QString &QString::prepend(QChar ch)

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

QString &QString::prepend(QLatin1StringView str)

将str 所处理的Latin-1字符串追加到此字符串的开头。

[since 6.0] QString &QString::prepend(QStringView str)

将字符串视图str 追加到该字符串的开头，并返回该字符串的引用。

该函数在 Qt 6.0 中引入。

[since 6.5] QString &QString::prepend(QUtf8StringView str)

将 UTF-8 字符串视图str 追加到该字符串的开头。

该函数于 Qt 6.5 中引入。

QString &QString::prepend(const QByteArray &ba)

将字节数组ba 追加到该字符串的开头。该字节数组将通过fromUtf8()函数转换为Unicode。

您可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII 来禁用此功能。例如，如果您希望确保所有用户可见的字符串都经过QObject::tr() 处理，此功能便十分有用。

QString &QString::prepend(const char *str)

在该字符串前添加字符串str 。const char指针将通过fromUtf8()函数转换为Unicode。

您可以在编译应用程序时定义QT_NO_CAST_FROM_ASCII 来禁用此函数。例如，如果您希望确保所有用户可见的字符串都经过QObject::tr() 处理，这会非常有用。

QString &QString::prepend(const QChar *str, qsizetype len)

将QChar 数组str 中的len 个字符追加到该字符串的开头，并返回该字符串的引用。

void QString::push_back(const QString &other)

此函数是为了兼容STL而提供的，它将给定的other 字符串追加到该字符串的末尾。它等同于append(other) 。

另请参阅 append()。

void QString::push_back(QChar ch)

将给定的ch 字符追加到该字符串的末尾。

void QString::push_front(const QString &other)

此函数是为了兼容STL而提供的，它会将给定的other 字符串追加到该字符串的开头。它等同于prepend(other) 。

另请参阅 prepend()。

void QString::push_front(QChar ch)

将给定的ch 字符添加到该字符串的开头。

QString::reverse_iterator QString::rbegin()

返回一个STL 风格的反向迭代器，该迭代器指向字符串中第一个字符，且顺序为反向。

另请参阅 begin()、crbegin() 和rend()。

QString::const_reverse_iterator QString::rbegin() const

QString &QString::remove(const QRegularExpression &re)

从字符串中移除所有匹配正则表达式re 的部分，并返回该字符串的引用。例如：

QString r = "Telephone";
r.remove(QRegularExpression("[aeiou]."));
// r == "The"

元素删除操作将保留字符串的容量，不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请在最后一次更改字符串大小后调用squeeze()。

另请参阅 indexOf()、lastIndexOf() 和replace()。

QString &QString::remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive)

删除该字符串中所有出现ch 的字符，并返回该字符串的引用。

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

示例：

QString t = "Ali Baba";
t.remove(QChar('a'), Qt::CaseInsensitive);
// t == "li Bb"

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

删除元素将保留字符串的容量，不会减少已分配的内存量。若要释放多余的容量并尽可能释放更多内存，请在最后一次更改字符串大小后调用squeeze()。

另请参阅 replace()。

QString &QString::remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive)

从该字符串中删除所有出现的指定str 字符串，并返回对该字符串的引用。

如果 `cs ` 为 `Qt::CaseSensitive `（默认值），则搜索区分大小写；否则，搜索不区分大小写。

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

删除元素将保留字符串的容量，不会减少已分配的内存量。要释放多余的容量并尽可能多地释放内存，请在最后一次更改字符串大小后调用squeeze()。

另请参阅 replace()。

QString &QString::remove(qsizetype position, qsizetype n)

从字符串中移除以给定position 索引位置为起点的n 字符，并返回该字符串的引用。

如果指定的position 索引位于字符串内部，但position +n 超出了字符串末尾，则字符串将在指定的position 处被截断。

如果n <= 0，则不进行任何更改。

QString s = "Montreal";
s.remove(1, 4);
// s == "Meal"

删除元素将保留字符串的容量，不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请在最后一次更改字符串大小后调用squeeze()。

另请参阅 insert() 和replace()。

QString &QString::remove(QLatin1StringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive)

从该字符串中移除所有由str 识别出的指定Latin-1字符串的出现位置，并返回该字符串的引用。

如果 `cs ` 为 `Qt::CaseSensitive `（默认值），则搜索区分大小写；否则，搜索不区分大小写。

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

删除元素将保留字符串的容量，不会减少已分配的内存量。若要释放多余的容量并尽可能多地释放内存，请在最后一次更改字符串大小后调用squeeze()。

另请参阅 replace()。

[since 6.5] QString &QString::removeAt(qsizetype pos)

删除索引为pos 处的字符。如果pos 超出范围（即pos >=size()），则该函数不执行任何操作。

该函数在 Qt 6.5 中引入。

另请参阅 remove()。

[since 6.5] QString &QString::removeFirst()

删除该字符串的第一个字符。如果字符串为空，则该函数不执行任何操作。

该函数自 Qt 6.5 起引入。

另请参阅 remove()。

[since 6.1] template <typename Predicate> QString &QString::removeIf(Predicate pred)

从字符串中移除所有满足谓词pred 返回 true 的元素。返回该字符串的引用。

该函数在 Qt 6.1 中引入。

另请参阅 remove()。

[since 6.5] QString &QString::removeLast()

删除该字符串的最后一个字符。如果字符串为空，则该函数不执行任何操作。

该函数于 Qt 6.5 版本中引入。

另请参阅 remove()。

QString::reverse_iterator QString::rend()

返回一个STL 风格的反向迭代器，该迭代器指向字符串中最后一个字符之后的位置，且按反向顺序排列。

另请参阅 end()、crend() 和rbegin()。

QString::const_reverse_iterator QString::rend() const

QString QString::repeated(qsizetype times) const

返回该字符串的副本，并按指定的times 次数进行重复。

如果 `times ` 小于 1，则返回空字符串。

示例：

QString str("ab");
str.repeated(4);            // returns "abababab"

QString &QString::replace(qsizetype position, qsizetype n, const QString &after)

将从索引position 开始的n 个字符替换为字符串after ，并返回对此字符串的引用。

示例：

QString x = "Say yes!";
QString y = "no";
x.replace(4, 3, y);
// x == "Say no!"

另请参阅 insert() 和remove()。

QString &QString::replace(const QRegularExpression &re, const QString &after)

将字符串中所有出现的正则表达式re 替换为after 。返回对该字符串的引用。例如：

QString s = "Banana";
s.replace(QRegularExpression("a[mn]"), "ox");
// s == "Boxoxa"

对于包含捕获组的正则表达式， \1、 \2、……等模式在after 中被替换为由相应捕获组捕获的字符串。

QString t = "A <i>bon mot</i>.";
t.replace(QRegularExpression("<i>([^<]*)</i>"), "\\emph{\\1}");
// t == "A \\emph{bon mot}."

另请参阅 indexOf()、lastIndexOf()、remove()、QRegularExpression 以及QRegularExpressionMatch 。

QString &QString::replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将字符before 替换为after （无论出现多少次），并返回对此字符串的引用。

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

QString &QString::replace(QChar c, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将字符c 替换为字符串after ，并返回该字符串的引用。

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

QString &QString::replace(QChar ch, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将字符串中所有出现的字符ch 替换为after ，并返回该字符串的引用。

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

QString &QString::replace(QLatin1StringView before, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将该字符串中由before 解析得到的 Latin-1 字符串的所有出现位置，替换为由after 解析得到的 Latin-1 字符串，并返回该字符串的引用。

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

QString &QString::replace(QLatin1StringView before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将该字符串中由before 解析的 Latin-1 字符串的所有出现位置替换为字符串after ，并返回该字符串的引用。

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

QString &QString::replace(const QString &before, QLatin1StringView after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将字符串“before ”的所有出现位置替换为“after ”，并返回该字符串的引用。

如果cs 等于Qt::CaseSensitive （默认情况），则搜索区分大小写；否则，搜索不区分大小写。

QString &QString::replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive)

将字符串before 替换为after （替换所有出现的位置），并返回该字符串的引用。

如果cs 为Qt::CaseSensitive （默认情况），则搜索区分大小写；否则，搜索不区分大小写。