Класс QString

Класс QString предоставляет строку символов Юникода. Подробнее...

• Список всех членов, включая унаследованные
• Устаревшие члены

Примечание: Все функции в этом классе являются реентерабельными.

Публичные типы

Публичные функции

Статические публичные члены

Связанные нечлены

Макросы

Подробное описание

QString хранит строку из 16-битных QChar, где каждый QChar соответствует одному UTF-16 кодовому элементу. (Символы Юникода с кодовыми значениями выше 65535 хранятся с использованием пар суррогатов, т.е. двумя последовательными QChar.)

Юникод — это международный стандарт, поддерживающий большинство современных систем письменности. Он является надмножеством US-ASCII (ANSI X3.4-1986) и Latin-1 (ISO 8859-1), и все символы US-ASCII/Latin-1 доступны на тех же позициях кодов.

Внутри QString используется неявное совместное использование (copy-on-write), чтобы уменьшить использование памяти и избежать ненужного копирования данных. Это также помогает уменьшить издержки, связанные с хранением 16-битных символов вместо 8-битных.

Помимо QString, Qt также предоставляет класс QByteArray для хранения сырых байтов и традиционных 8-битных строк, завершающихся символом '\0'. Для большинства целей класс QString — тот, который вы хотите использовать. Он используется во всей API Qt, а поддержка Юникода гарантирует, что ваши приложения будут легко переводиться, если вы хотите расширить рынок своего приложения в какой-то момент. Два основных случая, когда QByteArray подходит, — это когда вам нужно хранить сырые двоичные данные и когда критично экономия памяти (например, в встроенных системах).

Инициализация строки

Один из способов инициализации QString — просто передать const char * в его конструктор. Например, следующий код создаёт QString размером 5, содержащий данные "Hello":

QString str = "Hello";

QString преобразует const char * данные в Юникод, используя функцию fromUtf8().

Во всех функциях QString, принимающих const char * параметры, const char * интерпретируется как классическая строка C-стиля, завершающаяся символом '\0', закодированная в UTF-8. Допустимо, чтобы const char * параметр был nullptr.

Вы также можете предоставить данные строки как массив QChar:

static const QChar data[4] = { 0x0055, 0x006e, 0x10e3, 0x03a3 };
QString str(data, 4);

QString создаёт глубокую копию данных QChar, поэтому вы можете изменить её позже без побочных эффектов. (Если по причинам производительности вы не хотите создавать глубокую копию данных символов, используйте QString::fromRawData() вместо этого.)

Ещё один подход — задать размер строки, используя resize(), и инициализировать данные символ за символом. QString использует индексы с нуля, как и массивы C++. Для доступа к символу по определённому индексу можно использовать operator[](). Для не-const строк operator[]() возвращает ссылку на символ, которую можно использовать в левой части присваивания. Например:

QString str;
str.resize(4);

str[0] = QChar('U');
str[1] = QChar('n');
str[2] = QChar(0x10e3);
str[3] = QChar(0x03a3);

Для чтения без записи альтернативный синтаксис — использовать функцию at():

QString str;

for (qsizetype i = 0; i < str.size(); ++i) {
    if (str.at(i) >= QChar('a') && str.at(i) <= QChar('f'))
        qDebug() << "Found character in range [a-f]";
}

Функция at() может быть быстрее, чем operator[](), поскольку она никогда не вызывает глубокую копию. В качестве альтернативы, используйте функции first(), last() или sliced() для извлечения нескольких символов за один раз.

QString может содержать символы '\0' (QChar::Null). Функция size() всегда возвращает размер всей строки, включая вложенные символы '\0'.

После вызова функции resize() значения вновь выделенных символов не определены. Чтобы установить все символы в строке на определённое значение, используйте функцию fill().

QString предоставляет десятки перегрузок, предназначенных для упрощения использования строк. Например, если вы хотите сравнить QString со строковым литералом, вы можете написать код так, и он будет работать как ожидается:

QString str;

if (str == "auto" || str == "extern"
        || str == "static" || str == "register") {
    // ...
}

Вы также можете передать строковые литералы в функции, принимающие QStrings в качестве аргументов, вызвав конструктор QString(const char *). Аналогично, вы можете передать QString в функцию, принимающую аргумент const char *, используя макрос qPrintable(), который возвращает заданный QString в качестве const char *. Это эквивалентно вызову <QString>.toLocal8Bit().constData().

Обработка данных строк

QString предоставляет следующие основные функции для изменения данных символов: append(), prepend(), insert(), replace() и remove(). Например:

QString str = "and";
str.prepend("rock ");     // str == "rock and"
str.append(" roll");        // str == "rock and roll"
str.replace(5, 3, "&");   // str == "rock & roll"

В приведённом выше примере первые два аргумента функции replace() — это позиция, с которой следует начать замену, и количество символов, которые следует заменить.

Когда функции, изменяющие данные, увеличивают размер строки, они могут привести к перераспределению памяти для объекта QString. В этом случае QString расширяется больше, чем это необходимо в данный момент, чтобы обеспечить место для дальнейшего расширения без перераспределения, пока размер строки значительно не увеличится.

Функции insert(), remove() и, при замене подстроки на подстроку другого размера, replace() могут быть медленными (в линейное время) для больших строк, поскольку они требуют перемещения многих символов в строке по крайней мере на одну позицию в памяти.

Если вы постепенно создаёте QString и заранее примерно знаете, сколько символов он будет содержать, вы можете вызвать reserve(), попросив QString предварительно выделить определённое количество памяти. Вы также можете вызвать capacity(), чтобы узнать, сколько памяти фактически выделено для QString.

QString предоставляет итераторы в стиле STL (QString::const_iterator и QString::iterator). На практике итераторы удобны при работе с универсальными алгоритмами, предоставляемыми стандартной библиотекой C++.

Примечание: Итераторы над QString и ссылки на отдельные символы в нём не могут гарантировать сохранение своей корректности после вызова любой не-const функции QString. Доступ к такому итератору или ссылке после вызова не-const функции приводит к неопределённому поведению. Если требуется стабильность для функциональности типа итераторов, вы должны использовать индексы вместо итераторов, так как они не связаны с внутренним состоянием QString и, следовательно, не становятся некорректными.

Примечание: Из-за неявного совместного использования первый оператор или функция, используемые над заданным QString, могут заставить его внутренне выполнить глубокую копию своих данных. Это делает все итераторы над строкой и ссылки на отдельные символы в ней некорректными. После первого не-const оператора операции, изменяющие QString, могут полностью (в случае перераспределения) или частично сделать итераторы и ссылки некорректными, но другие методы (такие как begin() или end()) этого не сделают. Доступ к итератору или ссылке после того, как они стали некорректными, приводит к неопределённому поведению.

Частая потребность заключается в удалении символов пробела из строки ('\n', '\t', ' ', и т. д.). Если вы хотите удалить пробелы с обеих концов QString, используйте функцию trimmed(). Если вы хотите удалить пробелы с обеих концов и заменить несколько последовательных пробелов одним пробелом в строке, используйте simplified().

Если вы хотите найти все вхождения определённого символа или подстроки в QString, используйте функции indexOf() или lastIndexOf(). Первая ищет вперёд, начиная с заданной позиции индекса, вторая — назад. Обе возвращают позицию индекса символа или подстроки, если находят; в противном случае возвращают -1. Например, вот типичный цикл, который находит все вхождения определённой подстроки:

QString str = "We must be <b>bold</b>, very <b>bold</b>";
qsizetype j = 0;

while ((j = str.indexOf("<b>", j)) != -1) {
    qDebug() << "Found <b> tag at index position" << j;
    ++j;
}

QString предоставляет множество функций для преобразования чисел в строки и строк в числа. См. функции arg(), функции setNum(), статические функции number() и функции toInt(), toDouble() и аналогичные.

Чтобы получить версию строки в верхнем или нижнем регистре, используйте toUpper() или toLower().

Список строк обрабатывается классом QStringList. Вы можете разделить строку на список строк, используя функцию split(), и объединить список строк в одну строку с необязательным разделителем, используя QStringList::join(). Вы можете получить список строк из списка строк, содержащих определённую подстроку или соответствующих определённому QRegularExpression, используя функцию QStringList::filter().

Проверка данных строк

Если вы хотите проверить, начинается ли QString или заканчивается ли он определённой подстрокой, используйте startsWith() или endsWith(). Если вы просто хотите проверить, содержит ли QString определённый символ или подстроку, используйте функцию contains(). Если вы хотите узнать, сколько раз определённый символ или подстрока встречаются в строке, используйте count().

Чтобы получить указатель на фактические данные символов, вызовите data() или constData(). Эти функции возвращают указатель на начало данных QChar. Указатель гарантированно остаётся корректным до тех пор, пока не вызвана не-const функция на QString.

Сравнение строк

QStrings могут быть сравнены с помощью перегруженных операторов, таких как operator<(), operator<=(), operator==(), operator>=() и т. д. Обратите внимание, что сравнение основано исключительно на числовых значениях Unicode символов. Оно очень быстрое, но не соответствует тому, что ожидал бы человек; функция QString::localeAwareCompare() обычно является лучшим выбором для сортировки строк пользовательского интерфейса, когда такое сравнение доступно.

В системах Unix (включая Linux, macOS и iOS), когда Qt связан с библиотекой ICU (что обычно и происходит), используется её локально-ориентированное сортирование. В противном случае, на macOS и iOS функция localeAwareCompare() сравнивает строки в соответствии с настройкой «Порядок для отсортированных списков» в панели «Международные настройки». В других системах Unix без ICU сравнение использует базовый strcoll() системной библиотеки.

Преобразование между кодированными данными строк и QString

QString предоставляет следующие три функции, которые возвращают const char * версию строки в виде QByteArray: toUtf8(), toLatin1() и toLocal8Bit().

• toLatin1() возвращает 8-битную строку с кодировкой Latin-1 (ISO 8859-1).
• toUtf8() возвращает 8-битную строку с кодировкой UTF-8. UTF-8 — это супермножество US-ASCII (ANSI X3.4-1986), которое поддерживает весь набор символов Unicode с помощью многобайтовых последовательностей.
• toLocal8Bit() возвращает 8-битную строку, используя локальную кодировку системы. Это то же самое, что toUtf8() в системах Unix.

Для преобразования из одной из этих кодировок QString предоставляет fromLatin1(), fromUtf8() и fromLocal8Bit(). Другие кодировки поддерживаются классами QStringEncoder и QStringDecoder.

Как упоминалось выше, QString предоставляет множество функций и операторов, которые облегчают взаимодействие со строками const char *. Но эта функциональность — это двойной меч: она делает QString удобнее в использовании, если все строки — US-ASCII или Latin-1, но всегда существует риск, что неявное преобразование из или в const char * выполняется с использованием неправильной 8-битной кодировки. Чтобы свести эти риски к минимуму, вы можете отключить эти неявные преобразования, определив некоторые из следующих препроцессорных символов:

• QT_NO_CAST_FROM_ASCII отключает автоматические преобразования из строковых литералов C и указателей на Unicode.
• QT_RESTRICTED_CAST_FROM_ASCII разрешает автоматические преобразования из символов C и массивов символов, но отключает автоматические преобразования из указателей на символы в Unicode.
• QT_NO_CAST_TO_ASCII отключает автоматическое преобразование из QString в строки C.

Затем вам нужно явно вызвать fromUtf8(), fromLatin1() или fromLocal8Bit() для создания QString из 8-битной строки или использовать лёгкий класс QLatin1String, например:

QString url = QLatin1String("http://www.unicode.org/");

Аналогично, вы должны явно вызвать toLatin1(), toUtf8() или toLocal8Bit() для преобразования QString в 8-битную строку.

QString Widget::boolToString(bool b)
{
    QString result;
    if (b)
        result = "True";
    else
        result = "False";
    return result;
}

Различие между нулевой и пустой строками

По историческим причинам QString различает нулевую строку и пустую строку. Нулевая строка — это строка, которая инициализируется с помощью конструктора по умолчанию QString или путём передачи (const char *)0 в конструктор. Пустая строка — это любая строка с размером 0. Нулевая строка всегда пустая, но пустая строка не обязательно нулевая:

QString().isNull();               // returns true
QString().isEmpty();              // returns true

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

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

Все функции, кроме isNull() обрабатывают пустые строки так же, как и пустые строки. Например, toUtf8().constData() возвращает допустимый указатель (не nullptr) на символ '\0' для пустой строки. Рекомендуется всегда использовать функцию isEmpty() и избегать isNull().

Форматы аргументов

В методах-членах, где можно указать аргумент формат (например, arg(), number()), аргумент формат может быть одним из следующих:

Точность также указывается с помощью аргумента формат. Для форматов 'e', 'E' и 'f', точность представляет количество цифр после десятичной точки. Для форматов 'g' и 'G', точность представляет максимальное количество значащих цифр (завершающие нули опускаются).

Более эффективный способ создания строк

Многие строки известны во время компиляции. Но тривиальный конструктор QString("Hello") скопирует содержимое строки, рассматривая его как Latin-1. Чтобы избежать этого, можно использовать макрос QStringLiteral, чтобы напрямую создать необходимые данные во время компиляции. При создании QString из литерала не происходит дополнительной нагрузки во время выполнения.

Несколько менее эффективным способом является использование QLatin1String. Этот класс оборачивает C-строковый литерал, предварительно вычисляет его длину во время компиляции и может использоваться для более быстрого сравнения с QStrings и преобразования в QStrings, чем обычный C-строковый литерал.

Используя оператор QString '+', легко создать сложную строку из нескольких подстрок. Вы часто будете писать код такого вида:

    QString foo;
    QString type = "long";

    foo = QLatin1String("vector<") + type + QLatin1String(">::iterator");

    if (foo.startsWith("(" + type + ") 0x"))
        ...

В этих способах создания строк нет ничего плохого, но есть несколько скрытых недостатков производительности. Начиная с Qt 4.6, их можно устранить.

Во-первых, многократное использование оператора '+' обычно означает несколько выделений памяти. При конкатенации n подстрок, где n > 2, может быть до n - 1 вызовов выделения памяти.

В 4.6 был добавлен внутренний шаблонный класс QStringBuilder вместе с несколькими вспомогательными функциями. Этот класс помечен как внутренний и не отображается в документации, так как вы не должны создавать его в своём коде. Его использование будет автоматическим, как описано ниже. Класс находится в src/corelib/tools/qstringbuilder.cpp, если вы хотите его изучить.

QStringBuilder использует шаблоны выражений и переопределяет оператор '%' так, что при использовании '%' для конкатенации строк вместо '+', конкатенация нескольких подстрок откладывается до тех пор, пока окончательный результат не будет присвоен QString. В этот момент размер памяти, необходимый для окончательного результата, известен. Затем выделение памяти вызывается один раз для получения требуемого места, и подстроки копируются в него по одной.

Дополнительная эффективность достигается за счёт инлайнинга и уменьшения количества ссылок (QString, созданный из QStringBuilder, как правило, имеет счётчик ссылок 1, в то время как QString::append() требует дополнительной проверки).

Есть два способа доступа к этому улучшенному методу создания строк. Простой способ заключается в включении QStringBuilder везде, где нужно использовать его, и использовании оператора '%' вместо '+' при конкатенации строк:

    #include <QStringBuilder>

    QString hello("hello");
    QStringView el = QStringView{ hello }.mid(2, 3);
    QLatin1String world("world");
    QString message =  hello % el % world % QChar('!');

Более глобальный подход, который является наиболее удобным, но не полностью совместимым с исходным кодом, заключается в определении в файле .pro:

    DEFINES *= QT_USE_QSTRINGBUILDER

и '+' будет автоматически применено как QStringBuilder '%' везде.

Максимальный размер и условия недостатка памяти

Максимальный размер QString зависит от архитектуры. Большинство 64-битных систем могут выделять более 2 ГБ памяти, с типичным ограничением в 2^63 байта. Фактическое значение также зависит от накладных расходов, необходимых для управления блоком данных. В результате, вы можете ожидать максимальный размер в 2 ГБ минус накладные расходы на 32-битных платформах и 2^63 байта минус накладные расходы на 64-битных платформах. Количество элементов, которые можно хранить в QString, равно максимальному размеру, делённому на размер QChar.

При неудачном выделении памяти QString выбрасывает исключение std::bad_alloc если приложение было скомпилировано с поддержкой исключений. Условия недостатка памяти в контейнерах Qt — единственный случай, когда Qt будет выбрасывать исключения. Если исключения отключены, поведение при отсутствии памяти не определено.

Обратите внимание, что операционная система может накладывать дополнительные ограничения на приложения, удерживающие много выделенной памяти, особенно на большие, непрерывные блоки. Такие соображения, конфигурация такого поведения или любые методы смягчения лежат за пределами области применения API Qt.

См. также fromRawData(), QChar, QStringView, QLatin1String и QByteArray.

Документация по типам членов

QString::ConstIterator

Синоним Qt-стиля для QString::const_iterator.

QString::Iterator

Синоним Qt-стиля для QString::iterator.

enum QString::NormalizationForm

Этот перечисление описывает различные нормализованные формы текста Юникода.

См. также normalized() и Приложения к стандарту Юникода №15.

enum QString::SectionFlagflags QString::SectionFlags

Это перечисление определяет флаги, которые могут использоваться для изменения различных аспектов поведения функции section() в отношении разделителей и пустых полей.

Тип SectionFlags — это псевдоним для QFlags<SectionFlag>. Он хранит результат побитового ИЛИ для значений SectionFlag.

См. также section().

QString::const_iterator

См. также QString::iterator.

QString::const_pointer

Тип QString::const_pointer предоставляет указатель const STL-стиля на элемент QString (QChar).

QString::const_reference

[since 5.6] QString::const_reverse_iterator

Этот тип данных был введён в Qt 5.6.

См. также QString::reverse_iterator и QString::const_iterator.

QString::difference_type

QString::iterator

См. также QString::const_iterator.

QString::pointer

Тип QString::pointer предоставляет указатель STL-стиля на элемент QString (QChar).

QString::reference

[since 5.6] QString::reverse_iterator

Этот тип данных был введён в Qt 5.6.

См. также QString::const_reverse_iterator и QString::iterator.

QString::size_type

QString::value_type

Документация по методам-членам

Разделяет строку на подстроки в местах, где встречается sep, и возвращает ленивую последовательность этих строк.

Эквивалентно

return QStringTokenizer{std::forward<Needle>(sep), flags...};

кроме того, что работает без включенной в компиляторе поддержки C++17 Class Template Argument Deduction (CTAD).

См. QStringTokenizer, чтобы узнать, как sep и flags взаимодействуют, чтобы сформировать результат.

Примечание: Хотя эта функция возвращает QStringTokenizer, вы никогда не должны явно указывать её шаблонные аргументы. Если вы можете использовать C++17 Class Template Argument Deduction (CTAD), вы можете написать

QStringTokenizer result = sv.tokenize(sep);

(без шаблонных аргументов). Если вы не можете использовать C++17 CTAD, вы должны хранить возвращаемое значение только в auto переменных:

auto result = sv.tokenize(sep);

Это связано с тем, что шаблоновые аргументы QStringTokenizer имеют очень тонкое зависимость от конкретной перегрузки tokenize() функции, от которой они возвращаются, и они обычно не соответствуют типу, используемому для разделителя.

Эта функция была добавлена в Qt 6.0.

См. также QStringTokenizer и qTokenize().

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

Заменяет вхождения %N в этой строке соответствующим аргументом из args. Аргументы не являются позиционными: первый из args заменяет %N с наименьшим N (из всех), второй из args заменяет %N с последующим наименьшим N и так далее.

Args может содержать что угодно, что неявно преобразуется в QString, QStringView или QLatin1String.

Кроме того, также поддерживаются следующие типы: QChar, QLatin1Char.

Эта функция была добавлена в Qt 5.14.

См. также QString::arg().

QString::QString(const QByteArray &ba)

Конструирует строку, инициализированную байтовым массивом ba. Указанный байтовый массив преобразуется в Unicode с помощью fromUtf8(). Остановка копирования происходит по достижении первого символа 0, в противном случае копируется весь байтовый массив.

Вы можете отключить этот конструктор, определив QT_NO_CAST_FROM_ASCII при компиляции своих приложений. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

См. также fromLatin1(), fromLocal8Bit() и fromUtf8().

QString::QString(const char *str)

Конструирует строку, инициализированную 8-битной строкой str. Указанный указатель const char преобразуется в Unicode с помощью функции fromUtf8().

Вы можете отключить этот конструктор, определив QT_NO_CAST_FROM_ASCII при компиляции своих приложений. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

Примечание: Определение QT_RESTRICTED_CAST_FROM_ASCII также отключает этот конструктор, но вместо него включает QString(const char (&ch)[N]) конструктор. Использование нелитеральных входных данных или входных данных с встраиваемыми символами NUL или символами, не являющимися 7-битными, в этом случае неопределено.

См. также fromLatin1(), fromLocal8Bit() и fromUtf8().

[since 5.2] QString::QString(QString &&other)

Конструирует QString, ссылаясь на тот же объект, на который ссылается other.

Эта функция была добавлена в Qt 5.2.

QString::QString(const QString &other)

Конструирует копию other.

Эта операция занимает постоянное время, потому что QString использует неявное совместное использование. Это делает возврат QString из функции очень быстрым. Если изменён экземпляр, использующий совместное использование, он будет скопирован (copy-on-write), что занимает линейное время.

См. также operator=().

[since 6.1] template <typename> QString::QString(const char8_t *str)

Конструирует строку, инициализированную UTF-8 строкой str. Указанный указатель const char8_t преобразуется в Unicode с помощью функции fromUtf8().

Эта функция была добавлена в Qt 6.1.

См. также fromLatin1(), fromLocal8Bit() и fromUtf8().

QString::QString(QLatin1String str)

Конструирует копию латинской строки str.

См. также fromLatin1().

QString::QString(qsizetype size, QChar ch)

Конструирует строку заданного размера size, где каждый символ равен ch.

См. также fill().

QString::QString(QChar ch)

Конструирует строку размером 1, содержащую символ ch.

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

Конструирует строку, инициализированную первыми size символами массива QChar unicode.

Если unicode равен 0, создаётся пустая строка.

Если size отрицательно, предполагается, что unicode указывает на массив, завершённый символом '\0', и его длина определяется динамически. Завершающий символ null не считается частью строки.

QString создаёт глубокую копию данных строки. Данные unicode копируются как есть, а маркер порядка байтов сохраняется, если он присутствует.

См. также fromRawData().

QString::QString()

Конструирует пустую строку. Пустые строки также являются нулевыми.

См. также isEmpty().

QString &QString::operator=(const QByteArray &ba)

Перегрузка оператора присваивания =.

Присваивает ba этой строке. Байтовый массив преобразуется в Unicode с помощью функции fromUtf8(). Конвертация прекращается при первом найденном символе NUL или при достижении конца байтового массива ba.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции своих приложений. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

[since 5.2] QString &QString::operator=(QString &&other)

Перемещающее присваивание other этому экземпляру QString.

Эта функция была добавлена в Qt 5.2.

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

Присваивает other этой строке и возвращает ссылку на эту строку.

QString::~QString()

Уничтожает строку.

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

Добавляет строку str в конец этой строки.

Пример:

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)

Эта функция перегружает append().

Добавляет символ ch к этой строке.

[since 5.0] QString &QString::append(const QChar *str, qsizetype len)

Эта функция перегружает append().

Добавляет len символов из массива QChar str к этой строке.

Эта функция была добавлена в Qt 5.0.

QString &QString::append(QLatin1String str)

Эта функция перегружает append().

Добавляет строку Latin-1 str к этой строке.

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

Эта функция перегружает append().

Добавляет строку str к этой строке. Указанный указатель const char преобразуется в Unicode с помощью функции fromUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_FROM_ASCII при компиляции ваших приложений. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

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

Эта функция перегружает append().

Добавляет массив байтов ba к этой строке. Указанный массив байтов преобразуется в Unicode с помощью функции fromUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_FROM_ASCII при компиляции ваших приложений. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

QString QString::arg(const QString &a, int fieldWidth = 0, QChar fillChar = QLatin1Char(' ')) const

Возвращает копию этой строки с заменой маркера с наименьшим номером на строку a, т.е., %1, %2, ..., %99.

fieldWidth задаёт минимальное количество места, которое должна занимать строка a. Если a требует меньше места, чем fieldWidth, она дополняется символом fillChar до fieldWidth. Положительное значение fieldWidth выравнивает текст вправо. Отрицательное значение fieldWidth выравнивает текст влево.

В этом примере показано, как мы можем создать строку для отображения прогресса обработки списка файлов:

QString i;           // current file's number
QString total;       // number of files to process
QString 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.

Одно из преимуществ использования arg() перед asprintf() заключается в том, что порядок числовых маркеров может меняться при переводе строк приложения на другие языки, но каждая arg() всё равно будет заменять маркер с наименьшим номером, независимо от его положения. Кроме того, если маркер %i встречается в строке более одного раза, arg() заменит все вхождения.

Если не осталось ни одного незамещённого маркера, выводится сообщение об ошибке, а результат неопределён. Номера маркеров должны быть в диапазоне от 1 до 99.

QString QString::arg(qlonglong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

fieldWidth задаёт минимальное количество места, занимаемое значением a, и заполняется символом fillChar. Положительное значение выравнивает текст вправо; отрицательное — влево.

Аргумент base определяет систему счисления для преобразования целого числа a в строку. Система счисления должна быть в диапазоне от 2 до 36, при этом 8 даёт восьмеричные, 10 — десятичные, а 16 — шестнадцатеричные числа.

Если fillChar равняется '0', используется нуль из текущего региона. Для отрицательных чисел нули могут появляться перед знаком минус.

QString QString::arg(qulonglong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

fieldWidth задаёт минимальное количество места, занимаемое значением a, и заполняется символом fillChar. Положительное значение выравнивает текст вправо; отрицательное — влево.

Аргумент base определяет систему счисления для преобразования целого числа a в строку. Система счисления должна быть в диапазоне от 2 до 36, при этом 8 даёт восьмеричные, 10 — десятичные, а 16 — шестнадцатеричные числа.

Если fillChar равняется '0', используется нуль из текущего региона. Для отрицательных чисел нули могут появляться перед знаком минус.

QString QString::arg(long a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

fieldWidth задаёт минимальное количество места, занимаемое значением a, и заполняется символом fillChar. Положительное значение выравнивает текст вправо; отрицательное — влево.

Аргумент a выражен в заданной системе счисления base, по умолчанию 10, и должен быть в диапазоне от 2 до 36.

Символ '%' может быть после 'L', в этом случае последовательность заменяется локализованным представлением a. Преобразование использует текущую локаль. Текущая локаль определяется настройками локали системы при запуске приложения. Она может быть изменена с помощью QLocale::setDefault(). Флаг 'L' игнорируется, если base не равно 10.

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"

Если fillChar равняется '0', используется нуль из текущего региона. Для отрицательных чисел нули могут появляться перед знаком минус.

QString QString::arg(ulong a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

fieldWidth задаёт минимальное количество места, занимаемое значением a, и заполняется символом fillChar. Положительное значение выравнивает текст вправо; отрицательное — влево.

Аргумент base определяет систему счисления для преобразования целого числа a в строку. Система счисления должна быть в диапазоне от 2 до 36, при этом 8 даёт восьмеричные, 10 — десятичные, а 16 — шестнадцатеричные числа.

Если fillChar равняется '0', используется нуль из текущего региона. Для отрицательных чисел нули могут появляться перед знаком минус.

QString QString::arg(int a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

Аргумент a выражен в системе счисления base, по умолчанию 10, и должен быть в диапазоне от 2 до 36. Для систем счисления, отличных от 10, a рассматривается как беззнаковое целое число.

fieldWidth задаёт минимальное количество места, занимаемое значением a, и заполняется символом fillChar. Положительное значение выравнивает текст вправо; отрицательное — влево.

Символ '%' может быть после 'L', в этом случае последовательность заменяется локализованным представлением a. Преобразование использует текущую локаль, установленную с помощью QLocale::setDefault(). Если текущая локаль не была указана, используется локаль "C". Флаг 'L' игнорируется, если base не равно 10.

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"

Если fillChar равняется '0', используется нуль из текущего региона. Для отрицательных чисел нули могут появляться перед знаком минус.

QString QString::arg(uint a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

Аргумент base определяет систему счисления для преобразования целого числа a в строку. Система счисления должна быть в диапазоне от 2 до 36.

Если fillChar равняется '0', используется нуль из текущего региона. Для отрицательных чисел нули могут появляться перед знаком минус.

QString QString::arg(short a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

fieldWidth задаёт минимальное количество места, занимаемое значением a, и заполняется символом fillChar. Положительное значение выравнивает текст вправо; отрицательное — влево.

Аргумент base определяет систему счисления для преобразования целого числа a в строку. Система счисления должна быть в диапазоне от 2 до 36, при этом 8 даёт восьмеричные, 10 — десятичные, а 16 — шестнадцатеричные числа.

Если fillChar равняется '0', используется нуль из текущего региона. Для отрицательных чисел нули могут появляться перед знаком минус.

QString QString::arg(ushort a, int fieldWidth = 0, int base = 10, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

fieldWidth задаёт минимальное количество символов, до которого a дополняется символом fillChar. Положительное значение создаёт текст, выровненный по правому краю; отрицательное значение — по левому.

Аргумент base задаёт систему счисления, используемую при преобразовании целого числа a в строку. Система счисления должна быть в диапазоне от 2 до 36, при этом 8 даёт восьмеричные, 10 — десятичные и 16 — шестнадцатеричные числа.

Если fillChar равно '0' (число 0, ASCII 48), используется нуль текущего языка. Для отрицательных чисел нулевое заполнение может появиться перед знаком минус.

QString QString::arg(double a, int fieldWidth = 0, char format = 'g', int precision = -1, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

Аргумент a форматируется в соответствии с заданными format и precision. Подробности см. в разделе Форматы аргументов.

fieldWidth задаёт минимальное количество символов, до которого a дополняется символом fillChar. Положительное значение создаёт текст, выровненный по правому краю; отрицательное значение — по левому.

Символ '%' может быть после 'L', в этом случае последовательность заменяется локализованным представлением a. Преобразование использует локаль по умолчанию, установленную с помощью QLocale::setDefault(). Если локаль по умолчанию не была указана, используется локаль "C".

Если fillChar равно '0' (число 0, ASCII 48), функция будет использовать нуль текущего языка для дополнения. Для отрицательных чисел нулевое дополнение, вероятно, появится перед знаком минус.

См. также QLocale::toString().

QString QString::arg(char a, int fieldWidth = 0, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

Аргумент a интерпретируется как символ Latin-1.

QString QString::arg(QChar a, int fieldWidth = 0, QChar fillChar = QLatin1Char(' ')) const

Эта функция перегружает arg().

QString QString::arg(QStringView a, int fieldWidth = 0, QChar fillChar = QLatin1Char(' ')) const

Это перегруженная функция.

Возвращает копию этой строки, в которой маркер с наименьшим номером заменён строкой a, т.е., %1, %2, ..., %99.

fieldWidth задаёт минимальное количество символов, которое должно занимать a. Если a занимает меньше места, чем fieldWidth, она дополняется символом fillChar. Положительное значение fieldWidth создаёт текст, выровненный по правому краю. Отрицательное значение fieldWidth создаёт текст, выровненный по левому краю.

В этом примере показано, как мы можем создать строку status для отчёта о ходе обработки списка файлов:

Вначале arg(i) заменяет %1. Затем arg(total) заменяет %2. Наконец, arg(fileName) заменяет %3.

Одно из преимуществ использования arg() по сравнению с asprintf() состоит в том, что порядок числовых маркеров может измениться, если строки приложения переведены на другие языки, но каждый вызов arg() всё равно заменит маркер с наименьшим номером, независимо от его местоположения. Кроме того, если маркер %i встречается в строке более одного раза, arg() заменяет все такие маркеры.

Если оставшихся не заменённых маркеров нет, выводится сообщение об ошибке, и результат неопределён. Номера маркеров должны быть в диапазоне от 1 до 99.

Функция была добавлена в Qt 5.10.

QString QString::arg(QLatin1String a, int fieldWidth = 0, QChar fillChar = QLatin1Char(' ')) const

Это перегруженная функция.

Возвращает копию этой строки, в которой маркер с наименьшим номером заменён строкой a, т.е., %1, %2, ..., %99.

fieldWidth задаёт минимальное количество символов, которое должно занимать a. Если a занимает меньше места, чем fieldWidth, она дополняется символом fillChar. Положительное значение fieldWidth создаёт текст, выровненный по правому краю. Отрицательное значение fieldWidth создаёт текст, выровненный по левому краю.

Одно из преимуществ использования arg() по сравнению с asprintf() состоит в том, что порядок числовых маркеров может измениться, если строки приложения переведены на другие языки, но каждый вызов arg() всё равно заменит маркер с наименьшим номером, независимо от его местоположения. Кроме того, если маркер %i встречается в строке более одного раза, arg() заменяет все такие маркеры.

Если оставшихся не заменённых маркеров нет, выводится сообщение об ошибке, и результат неопределён. Номера маркеров должны быть в диапазоне от 1 до 99.

Функция была добавлена в Qt 5.10.

QString QString::asprintf(const char *cformat, ...)

Безопасно строит форматированную строку из формата строки cformat и произвольного списка аргументов.

Строка формата поддерживает спецификаторы преобразования, модификаторы длины и флаги, предоставляемые функцией printf() в стандартной библиотеке C++. Строка cformat и аргументы должны быть закодированы в UTF-8.

Примечание: последовательность escape %lc ожидает символ Юникода типа char16_t, или ushort (как возвращается QChar::unicode()). Последовательность escape %ls ожидает указатель на нуль-терминированный массив символов Юникода типа char16_t, или ushort (как возвращается QString::utf16()). Это противоречит printf() в стандартной библиотеке C++, которая определяет %lc для вывода wchar_t и %ls для вывода wchar_t*, и также может вызывать предупреждения компилятора на платформах, где размер wchar_t не равен 16 битам.

Предупреждение: Не рекомендуется использовать QString::asprintf() в новом коде Qt. Вместо этого рассмотрите использование QTextStream или arg(), которые поддерживают строки Юникода без проблем и являются безопасными по типу. Вот пример с использованием QTextStream:

Для переводов, особенно если строки содержат более одной последовательности escape, следует рассмотреть использование функции arg(). Это позволяет контролировать порядок замен переводчику.

Функция была добавлена в Qt 5.5.

См. также arg().

const QChar QString::at(qsizetype position) const

Возвращает символ по заданному индексу position в строке.

position должен быть допустимым индексом в строке (т.е., 0 <= position < size()).

См. также operator[]().

QChar QString::back() const

Возвращает последний символ в строке. То же самое, что и at(size() - 1).

Функция предоставляется для совместимости со STL.

Предупреждение: Вызов этой функции для пустой строки является неопределённым поведением.

Функция была добавлена в Qt 5.10.

См. также front(), at(), и operator[]().

QChar &QString::back()

Возвращает ссылку на последний символ в строке. То же самое, что и operator[](size() - 1).

Функция предоставляется для совместимости со STL.

Предупреждение: Вызов этой функции для пустой строки является неопределённым поведением.

Функция была добавлена в Qt 5.10.

См. также front(), at(), и operator[]().

QString::iterator QString::begin()

Возвращает итератор STL, указывающий на первый символ в строке.

Предупреждение: Возвращённый итератор становится недействительным при отсоединении или при изменении QString.

См. также constBegin() и end().

QString::const_iterator QString::begin() const

Эта функция перегружает begin().

qsizetype QString::capacity() const

Возвращает максимальное количество символов, которое может храниться в строке без принудительной переаллокации.

Единственная цель этой функции — предоставить возможность тонкой настройки использования памяти QString. Как правило, вам редко потребуется вызывать эту функцию. Если вы хотите узнать, сколько символов содержится в строке, вызовите size().

Примечание: статически выделенная строка сообщит ёмкость 0, даже если она не пуста.

Примечание: Положение свободного пространства в блоке выделенной памяти не определено. Другими словами, не следует предполагать, что свободная память всегда расположена после инициализированных элементов.

См. также reserve() и squeeze().

[since 5.0] QString::const_iterator QString::cbegin() const

Возвращает постоянный итератор STL-стиля, указывающий на первый символ в строке.

Предупреждение: Возвращаемый итератор становится недействительным при отделении или при изменении объекта QString.

Эта функция была представлена в Qt 5.0.

См. также begin() и cend().

[since 5.0] QString::const_iterator QString::cend() const

Возвращает постоянный итератор STL-стиля, указывающий сразу после последнего символа в строке.

Предупреждение: Возвращаемый итератор становится недействительным при отделении или при изменении объекта QString.

Эта функция была представлена в Qt 5.0.

См. также 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().

[since 5.10] QString QString::chopped(qsizetype len) const

Возвращает строку, содержащую size() - len левых символов этой строки.

Примечание: Поведение не определено, если len отрицательно или больше size().

Эта функция была представлена в Qt 5.10.

См. также endsWith(), first(), last(), sliced(), chop() и truncate().

void QString::clear()

Очищает содержимое строки и делает ее пустой.

См. также resize() и isNull().

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

Сравнивает s1 с s2 и возвращает целое число меньше, равно или больше нуля, если s1 меньше, равно или больше 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>() и Сравнение строк.

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

Эта функция перегружает compare().

Лексически сравнивает эту строку с строкой other и возвращает целое число меньше, равно или больше нуля, если эта строка меньше, равна или больше, чем другая строка.

То же самое, что compare(*this, other, cs).

int QString::compare(QLatin1String other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Эта функция перегружает compare().

То же самое, что compare(*this, other, cs).

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

Эта функция перегружает compare().

Выполняет сравнение этого с s, используя настройку чувствительности к регистру cs.

Эта функция была представлена в Qt 5.12.

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

Эта функция перегружает compare().

Выполняет сравнение этого с ch, используя настройку чувствительности к регистру cs.

Эта функция была представлена в Qt 5.14.

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

Эта функция перегружает compare().

Выполняет сравнение s1 и s2, используя настройку чувствительности к регистру cs.

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

Эта функция перегружает compare().

Выполняет сравнение s1 и s2, используя настройку чувствительности к регистру cs.

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

Эта функция перегружает compare().

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

Эта функция перегружает compare().

QString::const_iterator QString::constBegin() const

Возвращает постоянный итератор STL-стиля, указывающий на первый символ в строке.

Предупреждение: Возвращаемый итератор становится недействительным при отделении или при изменении объекта QString.

См. также begin() и constEnd().

const QChar *QString::constData() const

Возвращает указатель на данные, хранящиеся в объекте QString. Указатель может использоваться для доступа к символам, составляющим строку.

Обратите внимание, что указатель остается действительным только до тех пор, пока строка не изменится.

Примечание: Возвращаемая строка может не быть завершена символом '\0'. Используйте size(), чтобы определить длину массива.

См. также data(), operator[]() и fromRawData().

QString::const_iterator QString::constEnd() const

Возвращает постоянный итератор STL-стиля, указывающий сразу после последнего символа в строке.

Предупреждение: Возвращаемый итератор становится недействительным при отделении или при изменении объекта QString.

См. также constBegin() и end().

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

Возвращает true , если эта строка содержит вхождение строки str; в противном случае возвращает 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

Эта функция перегружает contains().

Возвращает true , если эта строка содержит вхождение символа ch; в противном случае возвращает false.

[since 5.3] bool QString::contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Эта функция перегружает contains().

Возвращает true если в этой строке есть вхождение латинской строки str; в противном случае возвращает false.

Эта функция была добавлена в Qt 5.3.

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

Эта функция перегружает contains().

Возвращает true если в этой строке есть вхождение указанного фрагмента строки str; в противном случае возвращает false.

Если cs имеет значение Qt::CaseSensitive (по умолчанию), поиск выполняется с учётом регистра; в противном случае — без учёта регистра.

Эта функция была добавлена в Qt 5.14.

См. также indexOf() и count().

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

Возвращает true если регулярное выражение re совпадает с частью этой строки; в противном случае возвращает false.

Если совпадение найдено и rmatch не nullptr, результаты совпадения записываются в объект QRegularExpressionMatch, на который указывает rmatch.

Эта функция была добавлена в Qt 5.1.

См. также QRegularExpression::match().

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

Возвращает количество (возможно, перекрывающихся) вхождений строки str в этой строке.

Если cs имеет значение Qt::CaseSensitive (по умолчанию), поиск выполняется с учётом регистра; в противном случае — без учёта регистра.

См. также contains() и indexOf().

qsizetype QString::count() const

Эта функция перегружает count().

То же самое, что и size().

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

Эта функция перегружает count().

Возвращает количество вхождений символа ch в строке.

Если cs имеет значение Qt::CaseSensitive (по умолчанию), поиск выполняется с учётом регистра; в противном случае — без учёта регистра.

См. также contains() и indexOf().

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

Эта функция перегружает count().

Возвращает количество (возможно, перекрывающихся) вхождений фрагмента строки str в этой строке.

Если cs имеет значение Qt::CaseSensitive (по умолчанию), поиск выполняется с учётом регистра; в противном случае — без учёта регистра.

Эта функция была добавлена в Qt 6.0.

См. также contains() и indexOf().

[since 5.0] qsizetype QString::count(const QRegularExpression &re) const

Эта функция перегружает count().

Возвращает количество совпадений с регулярным выражением re в строке.

По историческим причинам, эта функция считает перекрывающиеся совпадения, поэтому в примере ниже есть четыре вхождения «ана» или «ама»:

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

Это поведение отличается от простого перебора совпадений в строке с помощью QRegularExpressionMatchIterator.

Эта функция была добавлена в Qt 5.0.

См. также QRegularExpression::globalMatch().

[since 5.6] QString::const_reverse_iterator QString::crbegin() const

Возвращает постоянный итератор обратного обхода, указывающий на первый символ в строке в обратном порядке.

Предупреждение: Возвращаемый итератор становится недействительным при отсоединении или при изменении строки QString.

Эта функция была добавлена в Qt 5.6.

См. также begin(), rbegin(), и rend().

[since 5.6] QString::const_reverse_iterator QString::crend() const

Возвращает постоянный итератор обратного обхода, указывающий на позицию сразу после последнего символа в строке в обратном порядке.

Предупреждение: Возвращаемый итератор становится недействительным при отсоединении или при изменении строки QString.

Эта функция была добавлена в Qt 5.6.

См. также 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

Это перегруженная функция.

Примечание: Возвращаемая строка может не завершаться символом '\0'. Используйте size() для определения длины массива.

См. также fromRawData().

QString::iterator QString::end()

Возвращает итератор, указывающий на позицию сразу после последнего символа в строке.

Предупреждение: Возвращаемый итератор становится недействительным при отсоединении или при изменении строки QString.

См. также begin() и constEnd().

QString::const_iterator QString::end() const

Эта функция перегружает end().

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

Возвращает true если строка оканчивается на s; в противном случае возвращает false.

Если cs имеет значение Qt::CaseSensitive (по умолчанию), поиск выполняется с учётом регистра; в противном случае — без учёта регистра.

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

См. также startsWith().

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

Эта функция перегружает endsWith().

Возвращает true если строка оканчивается на указанный фрагмент строки str; в противном случае возвращает false.

Если cs имеет значение Qt::CaseSensitive (по умолчанию), поиск выполняется с учётом регистра; в противном случае — без учёта регистра.

Эта функция была добавлена в Qt 5.10.

См. также startsWith().

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

Эта функция перегружает endsWith().

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

Возвращает true если строка оканчивается на c; в противном случае возвращает false.

Эта функция перегружает endsWith().

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

Удаляет из строки символы в полуоткрытом диапазоне [ first , last ). Возвращает итератор, ссылающийся на символ last до удаления.

Эта функция была добавлена в Qt 6.1.

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

[since 6.0] QString QString::first(qsizetype n) const

Возвращает строку, содержащую первые n символов этой строки.

Примечание: Поведение не определено, когда n < 0 или n > размер().

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

Эта функция была добавлена в Qt 6.0.

См. также last(), sliced(), startsWith(), chopped(), chop(), и truncate().

[static, since 5.2] QString QString::fromCFString(CFStringRef string)

Создаёт новый QString, содержащий копию CFString string.

Примечание: эта функция доступна только на macOS и iOS.

Эта функция была добавлена в Qt 5.2.

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

Возвращает QString, инициализированную первыми size символами строки Latin-1 str.

Если size равно -1, strlen(str) используется вместо этого.

См. также toLatin1(), fromUtf8() и fromLocal8Bit().

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

Это перегруженная функция.

Возвращает QString, инициализированную строкой Latin-1 str.

Эта функция была добавлена в Qt 6.0.

[static, since 5.0] template <typename> QString QString::fromLatin1(const QByteArray &str)

Это перегруженная функция.

Возвращает QString, инициализированную строкой Latin-1 str.

Эта функция была добавлена в Qt 5.0.

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

Возвращает QString, инициализированную первыми size символами 8-битной строки str.

Если size равно -1, strlen(str) используется вместо этого.

В системах Unix это эквивалентно fromUtf8(), в Windows используется текущая кодовая страница системы.

См. также toLocal8Bit(), fromLatin1() и fromUtf8().

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

Это перегруженная функция.

Возвращает QString, инициализированную 8-битной строкой str.

Эта функция была добавлена в Qt 6.0.

[static, since 5.0] template <typename> QString QString::fromLocal8Bit(const QByteArray &str)

Это перегруженная функция.

Возвращает QString, инициализированную 8-битной строкой str.

Эта функция была добавлена в Qt 5.0.

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

Создаёт новый QString, содержащий копию NSString string.

Примечание: эта функция доступна только на macOS и iOS.

Эта функция была добавлена в Qt 5.2.

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

Создаёт QString, который использует первые size символов Юникода в массиве unicode. Данные в unicode не копируются. Вызывающий должен гарантировать, что unicode не будет удалён или изменён, пока существует QString (или немодифицированная копия).

Любые попытки изменить QString или копии приведут к созданию глубокой копии данных, гарантируя, что исходные данные не изменятся.

Вот пример того, как мы можем использовать QRegularExpression на исходных данных в памяти, не требуя копирования данных в QString:

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

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

Предупреждение: строка, созданная с помощью fromRawData(), не завершается '\0', за исключением случаев, когда исходные данные содержат символ '\0' в позиции size. Это означает, что unicode() не вернёт строку, завершённую '\0' (хотя utf16() вернёт, но это сопряжено с копированием исходных данных).

См. также fromUtf16() и setRawData().

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

Возвращает копию строки str. Указанная строка преобразуется в Юникод с помощью функции fromUtf8().

См. также fromLatin1(), fromLocal8Bit(), fromUtf8() и QByteArray::fromStdString().

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

Возвращает копию строки str. Предполагается, что заданная строка закодирована в UTF-16.

Эта функция была добавлена в Qt 5.5.

См. также fromUtf16(), fromStdWString() и fromStdU32String().

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

Возвращает копию строки str. Предполагается, что заданная строка закодирована в UCS-4.

Эта функция была добавлена в Qt 5.5.

См. также fromUcs4(), fromStdWString() и fromStdU16String().

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

Возвращает копию строки str. Предполагается, что заданная строка закодирована в utf16, если размер wchar_t равен 2 байтам (например, в Windows), и в ucs4, если размер wchar_t равен 4 байтам (большинство систем Unix).

См. также fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4(), fromStdU16String() и fromStdU32String().

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

Возвращает QString, инициализированную первыми size символами Юникод-строки unicode (кодировка ISO-10646-UCS-4).

Если size равно -1 (по умолчанию), unicode должен быть завершён символом '\0'.

Эта функция была добавлена в Qt 5.3.

См. также toUcs4(), fromUtf16(), utf16(), setUtf16(), fromWCharArray() и fromStdU32String().

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

Возвращает QString, инициализированную первыми size байтами UTF-8 строки str.

Если size равно -1, strlen(str) используется вместо этого.

UTF-8 — это кодировка Юникода и может представлять все символы в строке Юникода, такой как QString. Однако с UTF-8 возможны недопустимые последовательности, и в случае их обнаружения они будут заменены одним или несколькими «символами замены» или подавлены. Это включает в себя не-Юникод последовательности, не-символы, избыточные последовательности или суррогатные кодпоинты, закодированные в UTF-8.

Эта функция может использоваться для обработки поступающих данных по частям, пока все символы UTF-8 не будут завершены в поступающих данных. Любые незавершенные символы в конце строки будут заменены или подавлены. Для выполнения состоятельного декодирования используйте QStringDecoder.

См. также toUtf8(), fromLatin1() и fromLocal8Bit().

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

Это перегруженный метод.

Возвращает QString, инициализированный строкой UTF-8 str.

Этот метод был добавлен в Qt 6.0.

[static, since 5.0] template <typename> QString QString::fromUtf8(const QByteArray &str)

Это перегруженный метод.

Возвращает QString, инициализированный строкой UTF-8 str.

Этот метод был добавлен в Qt 5.0.

[static, since 6.1] template <typename> QString QString::fromUtf8(const char8_t *str)

Это перегруженный метод.

Этот перегруз доступен только при компиляции в режиме C++20.

Этот метод был добавлен в Qt 6.1.

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

Это перегруженный метод.

Этот перегруз доступен только при компиляции в режиме C++20.

Этот метод был добавлен в Qt 6.0.

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

Возвращает QString, инициализированный первыми size символами строке Unicode unicode (кодировка ISO-10646-UTF-16).

Если size равно -1 (по умолчанию), unicode должна быть завершена нулем '\0'.

Метод проверяет наличие метки порядка байтов (BOM). Если её нет, предполагается порядок байтов хоста.

Этот метод медленный по сравнению с другими преобразованиями Unicode. Если возможно, используйте QString(const QChar *, int) или QString(const QChar *).

QString создаёт глубокую копию данных Unicode.

Этот метод был добавлен в Qt 5.3.

См. также utf16(), setUtf16(), и fromStdU16String().

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

Возвращает копию string, где кодировка string зависит от размера wchar. Если wchar имеет 4 байта, string интерпретируется как UCS-4, если 2 байта — как UTF-16.

Если size равно -1 (по умолчанию), string должна быть завершена нулём '\0'.

См. также fromUtf16(), fromLatin1(), fromLocal8Bit(), fromUtf8(), fromUcs4(), и fromStdWString().

[since 5.10] QChar QString::front() const

Возвращает первый символ в строке. То же, что и at(0).

Этот метод предоставлен для совместимости со STL.

Предупреждение: Вызов этого метода для пустой строки приводит к неопределённому поведению.

Этот метод был добавлен в Qt 5.10.

См. также back(), at(), и operator[]().

[since 5.10] QChar &QString::front()

Возвращает ссылку на первый символ в строке. То же, что и operator[](0).

Этот метод предоставлен для совместимости со STL.

Предупреждение: Вызов этого метода для пустой строки приводит к неопределённому поведению.

Этот метод был добавлен в Qt 5.10.

См. также back(), at(), и operator[]().

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

Возвращает позицию первого вхождения строки str в этой строке, начиная поиск с позиции from. Возвращает -1, если str не найдена.

Если 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

Этот метод перегружает indexOf().

Возвращает позицию первого вхождения символа ch в строке, начиная поиск с позиции from. Возвращает -1, если ch не найдена.

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

Возвращает позицию первого вхождения строки str в этой строке, начиная поиск с позиции from. Возвращает -1, если str не найдена.

Если 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().

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

Этот метод перегружает indexOf().

Возвращает позицию первого вхождения строкового представления str в этой строке, начиная поиск с позиции from. Возвращает -1, если str не найдена.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; иначе — регистронезависимый.

Если from равно -1, поиск начинается с последнего символа; если -2, со второго с конца и так далее.

Этот метод был добавлен в Qt 5.14.

См. также QStringView::indexOf(), lastIndexOf(), contains(), и count().

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

Возвращает позицию первого совпадения регулярного выражения re в строке, начиная поиск с позиции from. Возвращает -1, если re не найдено нигде.

Если совпадение найдено и rmatch не nullptr, оно также записывает результаты совпадения в объект QRegularExpressionMatch, на который указывает rmatch.

Пример:

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

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

Этот метод был добавлен в Qt 5.5.

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

Вставляет строку str в указанную позицию position и возвращает ссылку на эту строку.

Пример:

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

Размер этой строки увеличивается для размещения вставки. Если position находится за пределами строки, к строке добавляются пробелы до достижения этой position, за которыми следует str.

См. также append(), prepend(), replace(), и remove().

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

Этот метод перегружает insert().

Вставляет ch в указанную позицию position в строке.

Размер этой строки увеличивается для размещения вставки. Если position находится за пределами строки, к строке добавляются пробелы до достижения этой position, за которыми следует ch.

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

Этот метод перегружает insert().

Вставляет первые size символов массива QChar unicode в указанную позицию position в строке.

Размер этой строки увеличивается для размещения вставки. Если position находится за пределами строки, к строке добавляются пробелы до достижения этой position, за которыми следует size символов массива QChar unicode.

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

Эта функция перегружает insert().

Вставляет строку str по указанному индексу position и возвращает ссылку на эту строку.

Эта строка увеличивается, чтобы вместить вставку. Если position находится за пределами конца строки, к строке добавляются пробелы, чтобы достичь этого position, а затем str.

Эта функция была добавлена в Qt 6.0.

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

Эта функция перегружает insert().

Вставляет строку Latin-1 str по указанному индексу position.

Эта строка увеличивается, чтобы вместить вставку. Если position находится за пределами конца строки, к строке добавляются пробелы, чтобы достичь этого position, а затем str.

[since 5.5] QString &QString::insert(qsizetype position, const char *str)

Эта функция перегружает insert().

Вставляет строку C str по указанному индексу position и возвращает ссылку на эту строку.

Эта строка увеличивается, чтобы вместить вставку. Если position находится за пределами конца строки, к строке добавляются пробелы, чтобы достичь этого position, а затем str.

Эта функция недоступна, когда определено QT_NO_CAST_FROM_ASCII.

Эта функция была добавлена в Qt 5.5.

[since 5.5] QString &QString::insert(qsizetype position, const QByteArray &str)

Эта функция перегружает insert().

Интерпретирует содержимое str как UTF-8, вставляет закодированную в Unicode строку по указанному индексу position и возвращает ссылку на эту строку.

Эта строка увеличивается, чтобы вместить вставку. Если position находится за пределами конца строки, к строке добавляются пробелы, чтобы достичь этого position, а затем str.

Эта функция недоступна, когда определено QT_NO_CAST_FROM_ASCII.

Эта функция была добавлена в Qt 5.5.

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

[since 5.12] bool QString::isLower() const

Возвращает true если строка в нижнем регистре, то есть она идентична результату её преобразования в нижний регистр с помощью toLower().

Обратите внимание, что это не означает, что строка не содержит заглавных букв (некоторые заглавные буквы не имеют эквивалента в нижнем регистре; они остаются неизменными при преобразовании в нижний регистр с помощью toLower()). Для получения дополнительной информации см. стандарт Unicode, раздел 3.13.

Эта функция была добавлена в Qt 5.12.

См. также QChar::toLower() и isUpper().

bool QString::isNull() const

Возвращает true если эта строка равна null; в противном случае возвращает 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().

[since 5.12] bool QString::isUpper() const

Возвращает true если строка в верхнем регистре, то есть она идентична результату её преобразования в верхний регистр с помощью toUpper().

Обратите внимание, что это не означает, что строка не содержит строчных букв (некоторые строчные буквы не имеют эквивалента в верхнем регистре; они остаются неизменными при преобразовании в верхний регистр с помощью toUpper()). Для получения дополнительной информации см. стандарт Unicode, раздел 3.13.

Эта функция была добавлена в Qt 5.12.

См. также QChar::toUpper() и isLower().

[since 5.15] bool QString::isValidUtf16() const

Возвращает true если строка содержит данные, валидные для UTF-16, или false в противном случае.

Обратите внимание, что эта функция не выполняет специальную проверку данных; она просто проверяет, может ли она быть успешно декодирована из UTF-16. Данные предполагаются в порядке байтов хоста; наличие BOM не имеет значения.

Эта функция была добавлена в Qt 5.15.

См. также QStringView::isValidUtf16().

[since 6.0] QString QString::last(qsizetype n) const

Возвращает строку, содержащую последние n символов этой строки.

Примечание: Поведение неопределено, когда n < 0 или n > size().

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

Эта функция была добавлена в Qt 6.0.

См. также first(), sliced(), endsWith(), chopped(), chop(), и truncate().

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

Возвращает позицию последнего вхождения строки str в этой строке, выполняя поиск назад от позиции from. Если from равно -1 (по умолчанию), поиск начинается с последнего символа; если from равно -2, с предпоследнего символа и так далее. Возвращает -1, если str не найдена.

Если 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().

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

Эта функция перегружает lastIndexOf().

Возвращает позицию последнего вхождения символа ch, выполняя поиск назад от позиции from.

qsizetype QString::lastIndexOf(QLatin1String str, qsizetype from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Эта функция перегружает lastIndexOf().

Возвращает позицию последнего вхождения строки str в этой строке, выполняя поиск назад от позиции from. Если from равно -1 (по умолчанию), поиск начинается с последнего символа; если from равно -2, с предпоследнего символа и так далее. Возвращает -1, если str не найдена.

Если 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().

[since 5.14] qsizetype QString::lastIndexOf(QStringView str, qsizetype from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Эта функция перегружает lastIndexOf().

Возвращает позицию последнего вхождения строки str в этой строке, выполняя поиск назад от позиции from. Если from равно -1 (по умолчанию), поиск начинается с последнего символа; если from равно -2, с предпоследнего символа и так далее. Возвращает -1, если str не найдена.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Эта функция была добавлена в Qt 5.14.

См. также indexOf(), contains(), и count().

[since 5.5] qsizetype QString::lastIndexOf(const QRegularExpression &re, qsizetype from = -1, QRegularExpressionMatch *rmatch = nullptr) const

Возвращает позицию последнего совпадения регулярного выражения re в строке, которое начинается перед позицией from. Возвращает -1, если re нигде не совпало.

Если совпадение успешно и rmatch не nullptr, оно также записывает результаты совпадения в объект QRegularExpressionMatch, на который указывает rmatch.

Пример:

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

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

Примечание: Из-за того, как работает алгоритм сопоставления с регулярным выражением, эта функция фактически будет многократно сопоставлять с начала строки до достижения позиции from.

Эта функция была добавлена в Qt 5.5.

QString QString::left(qsizetype n) const

Возвращает подстроку, содержащую n левых символов строки.

Если известно, что n не может выйти за пределы границ, используйте first() вместо этого в новом коде, так как это быстрее.

Возвращается вся строка, если n больше или равно size(), или меньше нуля.

См. также first(), last(), startsWith(), chopped(), chop(), и truncate().

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

Возвращает строку размером width, содержащую эту строку, дополненную символом fill.

Если truncate равно false и size() строки больше, чем width, возвращаемая строка — это копия строки.

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

Если truncate равно true и size() строки больше, чем width, любые символы в копии строки после позиции width удаляются, и возвращается копия.

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

См. также rightJustified().

qsizetype QString::length() const

Возвращает количество символов в этой строке. Эквивалентно size().

См. также resize().

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

Сравнивает s1 с s2 и возвращает целое число, меньшее, равное или больше нуля, если s1 меньше, равна или больше s2 соответственно.

Сравнение выполняется с учетом локали и платформы. Используйте эту функцию для представления отсортированных списков строк пользователю.

См. также compare(), QLocale и Сравнение строк.

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

Эта функция перегружает localeAwareCompare().

Сравнивает эту строку с строкой other и возвращает целое число, меньшее, равное или больше нуля, если эта строка меньше, равна или больше строки other соответственно.

Сравнение выполняется с учетом локали и платформы. Используйте эту функцию для представления отсортированных списков строк пользователю.

То же, что и localeAwareCompare(*this, other).

См. также Сравнение строк.

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

Эта функция перегружает localeAwareCompare().

Сравнивает эту строку со строкой other и возвращает целое число, меньшее, равное или больше нуля, если эта строка меньше, равна или больше строки other соответственно.

Сравнение выполняется с учетом локали и платформы. Используйте эту функцию для представления отсортированных списков строк пользователю.

То же, что и localeAwareCompare(*this, other).

Эта функция была добавлена в Qt 6.0.

См. также Сравнение строк.

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

Эта функция перегружает localeAwareCompare().

Сравнивает s1 с s2 и возвращает целое число, меньшее, равное или больше нуля, если s1 меньше, равна или больше s2 соответственно.

Сравнение выполняется с учетом локали и платформы. Используйте эту функцию для представления отсортированных списков строк пользователю.

Эта функция была добавлена в Qt 6.0.

См. также Сравнение строк.

QString QString::mid(qsizetype position, qsizetype n = -1) const

Возвращает строку, содержащую n символов этой строки, начиная с указанного индекса position.

Если известно, что position и n не могут выйти за пределы границ, используйте sliced() вместо этого в новом коде, так как это быстрее.

Возвращает пустую строку, если индекс position превышает длину строки. Если в строке доступно меньше, чем n символов, начиная с заданной позиции position, или если n равно -1 (по умолчанию), функция возвращает все доступные символы, начиная с указанной позиции.

См. также first(), last(), sliced(), chopped(), chop(), и truncate().

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

Возвращает строку в заданном режиме нормализации Юникода mode, в соответствии с заданной version стандарта Юникод.

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

Возвращает строковое представление числа n в указанной системе счисления base.

По умолчанию основание равно 10 и должно быть в диапазоне от 2 до 36. Для оснований, отличных от 10, n обрабатывается как целое без знака.

Форматирование всегда использует QLocale::C, т.е. английский/США. Для получения локализованного строкового представления числа используйте QLocale::toString() с соответствующей локалью.

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

См. также setNum().

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

Эта функция перегружена.

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

Эта функция перегружена.

[static] QString QString::number(ulong 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(double n, char format = 'g', int precision = 6)

Возвращает строковое представление числа n, отформатированного в соответствии с указанными format и precision. Подробнее см. Форматы аргументов.

В отличие от QLocale::toString(), эта функция не учитывает настройки локали пользователя.

См. также setNum() и QLocale::toString().

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)

Эта функция перегружает prepend().

Добавляет символ ch в начало этой строки.

[since 5.5] QString &QString::prepend(const QChar *str, qsizetype len)

Эта функция перегружает prepend().

Добавляет len символов из массива QChar str в начало этой строки и возвращает ссылку на эту строку.

Эта функция была добавлена в Qt 5.5.

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

Эта функция перегружает prepend().

Добавляет строку-представление str к началу этой строки и возвращает ссылку на эту строку.

Эта функция была добавлена в Qt 6.0.

QString &QString::prepend(QLatin1String str)

Эта функция перегружает prepend().

Добавляет строку Latin-1 str к этой строке.

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

Эта функция перегружает prepend().

Добавляет строку str к этой строке. Указатель const char преобразуется в Unicode с помощью функции fromUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_FROM_ASCII при компиляции ваших приложений. Это может быть полезно, если вы хотите убедиться, что все видимые пользователю строки проходят через QObject::tr(), например.

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

Эта функция перегружает prepend().

Добавляет массив байтов ba к этой строке. Массив байтов преобразуется в Unicode с помощью функции fromUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_FROM_ASCII при компиляции ваших приложений. Это может быть полезно, если вы хотите убедиться, что все видимые пользователю строки проходят через QObject::tr(), например.

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 в начало этой строки.

[since 5.6] QString::reverse_iterator QString::rbegin()

Возвращает обратный итератор STL, указывающий на первый символ в строке в обратном порядке.

Предупреждение: Возвращённый итератор становится недействительным при отделении или при модификации QString.

Эта функция была добавлена в Qt 5.6.

См. также begin(), crbegin() и rend().

[since 5.6] QString::const_reverse_iterator QString::rbegin() const

Это перегруженная функция.

Эта функция была добавлена в Qt 5.6.

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

Удаляет n символов из строки, начиная с указанного индекса position, и возвращает ссылку на строку.

Если указанный индекс position находится внутри строки, но position + n выходит за пределы строки, строка усекается до указанного индекса position.

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

Удаление элементов сохранит ёмкость строки и не уменьшит объём выделенной памяти. Чтобы освободить избыточную ёмкость и освободить как можно больше памяти, вызовите squeeze() после последнего изменения размера строки.

См. также insert() и replace().

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

Удаляет все вхождения символа ch в этой строке и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Пример:

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

Это то же самое, что replace(ch, "", cs).

Удаление элементов сохранит ёмкость строки и не уменьшит объём выделенной памяти. Чтобы освободить избыточную ёмкость и освободить как можно больше памяти, вызовите squeeze() после последнего изменения размера строки.

См. также replace().

[since 5.11] QString &QString::remove(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Это перегруженная функция.

Удаляет все вхождения заданной строки str в этой строке и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Это то же самое, что replace(str, "", cs).

Удаление элементов сохранит ёмкость строки и не уменьшит объём выделенной памяти. Чтобы освободить избыточную ёмкость и освободить как можно больше памяти, вызовите squeeze() после последнего изменения размера строки.

Эта функция была добавлена в Qt 5.11.

См. также replace().

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

Удаляет все вхождения заданной строки str в этой строке и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Это то же самое, что replace(str, "", cs).

Удаление элементов сохранит ёмкость строки и не уменьшит объём выделенной памяти. Чтобы освободить избыточную ёмкость и освободить как можно больше памяти, вызовите squeeze() после последнего изменения размера строки.

См. также replace().

[since 5.0] QString &QString::remove(const QRegularExpression &re)

Удаляет все вхождения регулярного выражения re в строке и возвращает ссылку на строку. Например:

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

Удаление элементов сохранит ёмкость строки и не уменьшит объём выделенной памяти. Чтобы освободить избыточную ёмкость и освободить как можно больше памяти, вызовите squeeze() после последнего изменения размера строки.

Эта функция была добавлена в Qt 5.0.

См. также indexOf(), lastIndexOf() и replace().

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

Удаляет из строки все элементы, для которых предикат pred возвращает true. Возвращает ссылку на строку.

Эта функция была добавлена в Qt 6.1.

См. также remove().

[since 5.6] QString::reverse_iterator QString::rend()

Возвращает обратный итератор STL, указывающий сразу за последним символом в строке в обратном порядке.

Предупреждение: Возвращённый итератор становится недействительным при отделении или при модификации QString.

Эта функция была добавлена в Qt 5.6.

См. также end(), crend() и rbegin().

[since 5.6] QString::const_reverse_iterator QString::rend() const

Это перегруженная функция.

Эта функция была добавлена в Qt 5.6.

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)

Заменяет n символов, начиная с индекса position, строкой after и возвращает ссылку на эту строку.

Примечание: Если указанный индекс position находится внутри строки, но position + n выходит за пределы диапазона строки, то n будет скорректирован, чтобы остановиться на конце строки.

Пример:

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

См. также insert() и remove().

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

Эта функция перегружает replace().

Заменяет n символов, начиная с индекса position, символом after и возвращает ссылку на эту строку.

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

Эта функция перегружает replace().

Заменяет n символов, начиная с индекса position, первыми size символами массива QChar unicode и возвращает ссылку на эту строку.

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

Эта функция перегружает replace().

Заменяет каждое вхождение символа before символом after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

QString &QString::replace(const QChar *before, qsizetype blen, const QChar *after, qsizetype alen, Qt::CaseSensitivity cs = Qt::CaseSensitive)

Эта функция перегружает replace().

Заменяет каждое вхождение в этой строке первых blen символов before первыми alen символами after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

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

Эта функция перегружает replace().

Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Примечание: Текст не перепроверяется после замены.

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

Эта функция перегружает replace().

Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Примечание: Текст не перепроверяется после замены.

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

Эта функция перегружает replace().

Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Примечание: Текст не перепроверяется после замены.

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

Эта функция перегружает replace().

Заменяет каждое вхождение строки before строкой after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Пример:

QString str = "colour behaviour flavour neighbour";
str.replace(QString("ou"), QString("o"));
// str == "color behavior flavor neighbor"

Примечание: Текст замены не перепроверяется после его вставки.

Пример:

QString equis = "xxxxxx";
equis.replace("xx", "x");
// equis == "xxx"

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

Эта функция перегружает replace().

Заменяет каждое вхождение символа ch в строке на after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

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

Эта функция перегружает replace().

Заменяет каждое вхождение символа c на строку after и возвращает ссылку на эту строку.

Если cs равно Qt::CaseSensitive (по умолчанию), поиск регистрозависимый; в противном случае поиск регистронезависимый.

Примечание: Текст не перепроверяется после замены.

[since 5.0] QString &QString::replace(const QRegularExpression &re, const QString &after)

Эта функция перегружает replace().

Заменяет каждое вхождение регулярного выражения 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}."

Эта функция была добавлена в Qt 5.0.

См. также indexOf(), lastIndexOf(), remove(), QRegularExpression и QRegularExpressionMatch.

void QString::reserve(qsizetype size)

Обеспечивает, что строка имеет место для как минимум size символов.

Если заранее известно, какой будет размер строки, можно вызвать эту функцию, чтобы избежать повторных перераспределений памяти при построении строки. Это может повысить производительность при построительном добавлении символов в строку. Длинная последовательность операций, добавляющих в строку символы, может вызвать несколько перераспределений, последнее из которых может оставить у вас значительно больше места, чем вам действительно нужно, что менее эффективно, чем одно выделение памяти нужного размера в начале.

Если вы не уверены, сколько места потребуется, обычно лучше использовать верхнюю границу как size или высокую оценку наиболее вероятного размера, если строгая верхняя граница будет намного больше этого. Если size является недооценкой, строка будет расти по мере необходимости, как только зарезервированный размер будет превышен, что может привести к большему выделению памяти, чем ваша лучшая переоценка, и замедлит операцию, которая ее спровоцирует.

Предупреждение: reserve() резервирует память, но не изменяет размер строки. Доступ к данным за пределами конца строки является неопределённым поведением. Если вам нужно получить доступ к памяти за пределами текущего конца строки, используйте resize().

Эта функция полезна для кода, который должен создавать длинную строку и хочет избежать многократного перераспределения памяти. В этом примере мы хотим добавлять в строку до тех пор, пока не выполнится какое-то условие true, и мы достаточно уверены, что размер достаточно большой, чтобы сделать вызов reserve() целесообразным:

QString result;
qsizetype maxSize;
bool condition;
QChar nextChar;

result.reserve(maxSize);

while (condition)
    result.append(nextChar);

result.squeeze();

См. также squeeze(), capacity() и resize().

void QString::resize(qsizetype size)

Устанавливает размер строки в size символов.

Если size больше текущего размера, строка расширяется до size символов, и новые символы добавляются в конец. Новые символы неинициализированы.

Если size меньше текущего размера, символы за позицией size исключаются из строки.

Примечание: Хотя resize() увеличит ёмкость при необходимости, он никогда не уменьшает ёмкость. Чтобы освободить избыточную ёмкость, используйте squeeze().

Пример:

QString s = "Hello world";
s.resize(5);
// s == "Hello"

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

Если вы хотите добавить определённое количество одинаковых символов в строку, используйте перегрузку resize(qsizetype, QChar).

Если вы хотите расширить строку до определённой ширины и заполнить новые позиции определённым символом, используйте функцию leftJustified():

Если size отрицательно, это эквивалентно передаче нуля.

QString r = "Hello";
r = r.leftJustified(10, ' ');
// r == "Hello     "

См. также truncate(), reserve() и squeeze().

[since 5.7] void QString::resize(qsizetype size, QChar fillChar)

Это перегруженная функция.

В отличие от resize(qsizetype), эта перегрузка инициализирует новые символы значением fillChar:

QString t = "Hello";
r.resize(t.size() + 10, 'X');
// t == "HelloXXXXXXXXXX"

Эта функция была добавлена в Qt 5.7.

QString QString::right(qsizetype n) const

Возвращает подстроку, содержащую n правых символов строки.

Если вы знаете, что n не может выйти за пределы, используйте last() вместо этого в новом коде, так как это быстрее.

Возвращается вся строка, если n больше или равно size() или меньше нуля.

См. также endsWith(), last(), first(), sliced(), chopped(), chop() и truncate().

QString QString::rightJustified(qsizetype width, QChar fill = QLatin1Char(' '), bool truncate = false) const

Возвращает строку длины size() width, содержащую символ fill, после которого следует исходная строка. Например:

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

Если truncate false и size() строки больше width, то возвращаемая строка является копией исходной строки.

Если truncate равно true и size() строки больше width, то возвращаемая строка усечена до позиции width.

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

См. также leftJustified().

QString QString::section(QChar sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

Эта функция возвращает часть строки.

Строка рассматривается как последовательность полей, разделённых символом sep. Возвращаемая строка состоит из полей от позиции start до позиции end включительно. Если end не указан, включаются все поля от позиции start до конца строки. Поля нумеруются с 0, 1, 2 и так далее, слева направо, и -1, -2 и так далее, справа налево.

Аргумент flags может быть использован для изменения некоторых аспектов поведения функции, например, для определения чувствительности к регистру, пропуска пустых полей и обработки начальных и конечных разделителей; см. SectionFlags.

QString str;
QString csv = "forename,middlename,surname,phone";
QString path = "/usr/local/bin/myapp"; // First field is empty
QString::SectionFlag flag = QString::SectionSkipEmpty;

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

Если start или end отрицательные, поля считаются справа от строки, правое поле – -1, следующий справа – -2 и так далее.

str = csv.section(',', -3, -2);  // str == "middlename,surname"
str = path.section('/', -1); // str == "myapp"

См. также split().

QString QString::section(const QString &sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

Эта функция перегружает section().

QString str;
QString data = "forename**middlename**surname**phone";

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

См. также split().

[since 5.0] QString QString::section(const QRegularExpression &re, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

Эта функция перегружает section().

Эта строка обрабатывается как последовательность полей, разделённых регулярным выражением re.

QString line = "forename\tmiddlename  surname \t \t phone";
QRegularExpression sep("\\s+");
str = line.section(sep, 2, 2); // str == "surname"
str = line.section(sep, -3, -2); // str == "middlename  surname"

Предупреждение: Использование этой версии с QRegularExpression намного дороже, чем перегруженные версии со строками и символами.

Эта функция была добавлена в Qt 5.0.

См. также split() и simplified().

QString &QString::setNum(int n, int base = 10)

Устанавливает строку в значение n в заданном основании base и возвращает ссылку на строку.

По умолчанию основание равно 10 и должно быть в диапазоне от 2 до 36. Для оснований, отличных от 10, n обрабатывается как беззнаковое целое число.

QString str;
str.setNum(1234);       // str == "1234"

Форматирование всегда использует QLocale::C, т. е. английский/США. Чтобы получить локальное строковое представление числа, используйте QLocale::toString() с соответствующей локалью.

См. также number().

QString &QString::setNum(short n, int base = 10)

Это перегруженная функция.

QString &QString::setNum(ushort n, int base = 10)

Это перегруженная функция.

QString &QString::setNum(uint n, int base = 10)

Это перегруженная функция.

QString &QString::setNum(long n, int base = 10)

Это перегруженная функция.

QString &QString::setNum(ulong n, int base = 10)

Это перегруженная функция.

QString &QString::setNum(qlonglong n, int base = 10)

Это перегруженная функция.

QString &QString::setNum(qulonglong n, int base = 10)

Это перегруженная функция.

QString &QString::setNum(float n, char format = 'g', int precision = 6)

Это перегруженная функция.

Устанавливает строку в значение n, отформатированное в соответствии с format и precision, и возвращает ссылку на строку.

Форматирование всегда использует QLocale::C, т. е. английский/США. Чтобы получить локальное строковое представление числа, используйте QLocale::toString() с соответствующей локалью.

См. также number().

QString &QString::setNum(double n, char format = 'g', int precision = 6)

Это перегруженная функция.

Устанавливает строку в значение n, отформатированное в соответствии с format и precision, и возвращает ссылку на строку.

format может быть 'e', 'E', 'f', 'g' или 'G' (см. Форматы аргументов для объяснения форматов).

Форматирование всегда использует QLocale::C, т. е. английский/США. Чтобы получить локальное строковое представление числа, используйте QLocale::toString() с соответствующей локалью.

См. также number().

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

Сбрасывает QString, чтобы использовать первые size Unicode-символов в массиве unicode. Данные в unicode не копируются. Вызывающий метод должен гарантировать, что unicode не будет удалён или изменён до тех пор, пока существует QString (или его неизменная копия).

Эта функция может быть использована вместо fromRawData() для повторного использования существующих объектов QString для экономии памяти при повторных выделениях.

См. также fromRawData().

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

Изменяет размер строки на size символов и копирует unicode в строку.

Если unicode — nullptr, ничего не копируется, но строка всё равно изменяет размер до size.

См. также unicode() и setUtf16().

QString &QString::setUtf16(const ushort *unicode, qsizetype size)

Изменяет размер строки до size символов и копирует unicode в строку.

Если unicode — nullptr, ничего не копируется, но строка всё равно изменяет размер до size.

Обратите внимание, что в отличие от fromUtf16(), эта функция не учитывает BOM и, возможно, различающиеся порядки байтов.

См. также utf16() и setUnicode().

[since 5.10] void QString::shrink_to_fit()

Эта функция предоставляется для совместимости со STL. Она эквивалентна squeeze().

Эта функция была добавлена в Qt 5.10.

См. также squeeze().

QString QString::simplified() const

Возвращает строку, из которой удалены пробелы в начале и конце, а каждая последовательность внутренних пробелов заменена на один пробел.

Пробелы означают любой символ, для которого QChar::isSpace() возвращает true. Это включает ASCII-символы '\t', '\n', '\v', '\f', '\r' и ' '.

Пример:

QString str = "  lots\t of\nwhitespace\r\n ";
str = str.simplified();
// str == "lots of whitespace";

См. также trimmed().

qsizetype QString::size() const

Возвращает количество символов в этой строке.

Последний символ в строке находится в позиции size() - 1.

Пример:

QString str = "World";
qsizetype n = str.size();   // n == 5
str.data()[0];              // returns 'W'
str.data()[4];              // returns 'd'

См. также isEmpty() и resize().

[since 6.0] QString QString::sliced(qsizetype pos, qsizetype n) const

Возвращает строку, содержащую n символов из этой строки, начиная с позиции pos.

Примечание: Поведение не определено, когда pos < 0, n < 0 или pos + n > size().

QString x = "Nine pineapples";
QString y = x.sliced(5, 4);            // y == "pine"
QString z = x.sliced(5);               // z == "pineapples"

Эта функция была добавлена в Qt 6.0.

См. также first(), last(), chopped(), chop() и truncate().

[since 6.0] QString QString::sliced(qsizetype pos) const

Это перегруженная функция.

Возвращает строку, содержащую часть этой строки, начинающуюся с позиции pos и продолжающуюся до её конца.

Примечание: Поведение не определено, когда pos < 0 или pos > size().

Эта функция была добавлена в Qt 6.0.

См. также first(), last(), sliced(), chopped(), chop() и truncate().

[since 5.14] QStringList QString::split(const QString &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Разделяет строку на подстроки там, где встречается sep, и возвращает список этих строк. Если sep нигде не совпадает со строкой, split() возвращает список, содержащий только эту строку.

cs определяет, будет ли совпадение с sep чувствительным к регистру или нет.

Если behavior равен Qt::SkipEmptyParts, пустые элементы не отображаются в результате. По умолчанию пустые элементы сохраняются.

Пример:

QString str = QStringLiteral("a,,b,c");

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

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

Если sep пустая, split() возвращает пустую строку, за которой следуют каждый символ строки, за которым следует ещё одна пустая строка:

QString str = "abc";
auto parts = str.split(QString());
// parts: {"", "a", "b", "c", ""}

Чтобы понять это поведение, вспомните, что пустая строка совпадает везде, поэтому вышеприведённое качественно то же самое, что и:

QString str = "/a/b/c/";
auto parts = str.split(QLatin1Char('/'));
// parts: {"", "a", "b", "c", ""}

Эта функция была добавлена в Qt 5.14.

См. также QStringList::join() и section().

[since 5.14] QStringList QString::split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Это перегруженная функция.

Эта функция была добавлена в Qt 5.14.

[since 5.14] QStringList QString::split(const QRegularExpression &re, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const

Это перегруженная функция.

Разделяет строку на подстроки там, где совпадает регулярное выражение re, и возвращает список этих строк. Если re нигде не совпадает со строкой, split() возвращает список, содержащий только эту строку.

Вот пример, где мы извлекаем слова в предложении, используя один или несколько пробелов в качестве разделителя:

QString str;
QStringList list;

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

Вот аналогичный пример, но на этот раз мы используем любую последовательность символов, не являющихся словами, в качестве разделителя:

str = "This time, a normal English sentence.";
list = str.split(QRegularExpression("\\W+"), Qt::SkipEmptyParts);
// list: [ "This", "time", "a", "normal", "English", "sentence" ]

Вот третий пример, где мы используем утверждение нулевой длины \b (граница слова), чтобы разбить строку на чередующуюся последовательность токенов, не являющихся словами, и токенов, являющихся словами:

str = "Now: this sentence fragment.";
list = str.split(QRegularExpression("\\b"));
// list: [ "", "Now", ": ", "this", " ", "sentence", " ", "fragment", "." ]

Эта функция была добавлена в Qt 5.14.

См. также QStringList::join() и section().

void QString::squeeze()

Освобождает память, не необходимую для хранения данных символов.

Единственная цель этой функции — предоставить способ тонкой настройки использования памяти QString. Как правило, вам редко понадобится вызывать эту функцию.

См. также reserve() и capacity().

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

Возвращает true если строка начинается с s; в противном случае возвращает false.

Если cs равен Qt::CaseSensitive (по умолчанию), поиск чувствителен к регистру; в противном случае поиск нечувствителен к регистру.

QString str = "Bananas";
str.startsWith("Ban");     // returns true
str.startsWith("Car");     // returns false

См. также endsWith().

[since 5.10] bool QString::startsWith(QStringView str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Это перегруженная функция.

Возвращает true если строка начинается с представления строки str; в противном случае возвращает false.

Если cs равен Qt::CaseSensitive (по умолчанию), поиск чувствителен к регистру; в противном случае поиск нечувствителен к регистру.

Эта функция была добавлена в Qt 5.10.

См. также endsWith().

bool QString::startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Эта функция перегружает startsWith().

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

Эта функция перегружает startsWith().

Возвращает true если строка начинается с c; в противном случае возвращает false.

void QString::swap(QString &other)

Меняет местами строки other и эту строку. Эта операция очень быстрая и никогда не терпит неудачу.

[since 5.2] CFStringRef QString::toCFString() const

Создаёт CFString из QString.

Вызывающая сторона владеет CFString и отвечает за его освобождение.

Примечание: эта функция доступна только на macOS и iOS.

Эта функция была добавлена в Qt 5.2.

QString QString::toCaseFolded() const

Возвращает эквивалент строки в нижнем регистре с учётом слияния регистров. Для большинства символов Юникода это то же самое, что toLower().

double QString::toDouble(bool *ok = nullptr) const

Возвращает строку, преобразованную в значение double.

Возвращает бесконечность, если преобразование переполняет, или 0.0, если преобразование терпит неудачу по другим причинам (например, подпоток).

Если ok не nullptr, неудача сообщается путём установки *ok в false, а успех — путём установки *ok в true.

QString str = "1234.56";
double val = str.toDouble();   // val == 1234.56

Предупреждение: Содержимое QString может содержать только допустимые числовые символы, включая знак плюс/минус, символ e в научной записи и десятичную точку. Включение единицы или дополнительных символов приводит к ошибке преобразования.

bool ok;
double d;

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

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

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toDouble()

d = QString( "1234,56" ).toDouble(&ok); // ok == false
d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56

По историческим причинам эта функция не обрабатывает разделители тысяч. Если вам нужно преобразовать такие числа, используйте QLocale::toDouble().

d = QString( "1,234,567.89" ).toDouble(&ok); // ok == false
d = QString( "1234567.89" ).toDouble(&ok); // ok == true

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), QLocale::setDefault(), QLocale::toDouble(), и trimmed().

float QString::toFloat(bool *ok = nullptr) const

Возвращает строку, преобразованную в значение float.

Возвращает бесконечность, если преобразование переполнило, или 0.0, если преобразование завершилось неудачно по другим причинам (например, подпотоковая обработка).

Если ok не nullptr, неудача сообщается путём установки *ok в false, а успех — путём установки *ok в true.

Предупреждение: Содержимое QString может содержать только допустимые числовые символы, включая знак плюс/минус, символ e в научной записи и десятичную точку. Включение единицы или дополнительных символов приводит к ошибке преобразования.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toFloat()

По историческим причинам эта функция не обрабатывает разделители тысяч. Если вам нужно преобразовать такие числа, используйте QLocale::toFloat().

Пример:

QString str1 = "1234.56";
str1.toFloat();             // returns 1234.56

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

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toDouble(), toInt(), QLocale::toFloat(), и trimmed().

[since 5.0] QString QString::toHtmlEscaped() const

Преобразует строку простого текста в HTML-строку, заменяя HTML-спецсимволы <, >, &, и " на HTML-сущности.

Пример:

QString plain = "#include <QtCore>"
QString html = plain.toHtmlEscaped();
// html == "#include &lt;QtCore&gt;"

Эта функция была добавлена в Qt 5.0.

int QString::toInt(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в int с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование завершается неудачно.

Если ok не nullptr, неудача сообщается путём установки *ok в false, а успех — путём установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с «0x», используется основание 16; если строка начинается с «0», используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toInt()

Пример:

QString str = "FF";
bool ok;
int hex = str.toInt(&ok, 16);       // hex == 255, ok == true
int dec = str.toInt(&ok, 10);       // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toUInt(), toDouble(), и QLocale::toInt().

QByteArray QString::toLatin1() const

Возвращает представление строки в формате Latin-1 в виде QByteArray.

Возвращаемый массив байтов неопределён, если строка содержит не-Latin1 символы. Эти символы могут быть подавлены или заменены вопросительным знаком.

См. также fromLatin1(), toUtf8(), toLocal8Bit(), и QStringEncoder.

QByteArray QString::toLocal8Bit() const

Возвращает локальное 8-битное представление строки в виде QByteArray. Возвращаемый массив байтов неопределён, если строка содержит символы, не поддерживаемые локальным 8-битным кодированием.

В системах Unix это эквивалентно toUtf8(), в Windows используется текущая кодовая страница системы.

Если эта строка содержит символы, которые не могут быть закодированы в локальной кодировке, возвращаемый массив байтов неопределён. Эти символы могут быть подавлены или заменены другим.

См. также fromLocal8Bit(), toLatin1(), toUtf8(), и QStringEncoder.

long QString::toLong(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в long с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование завершается неудачно.

Если ok не nullptr, неудача сообщается путём установки *ok в false, а успех — путём установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с «0x», используется основание 16; если строка начинается с «0», используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toLongLong()

Пример:

QString str = "FF";
bool ok;

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toULong(), toInt(), и QLocale::toInt().

qlonglong QString::toLongLong(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в long long с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование завершается неудачно.

Если ok не nullptr, неудача сообщается путём установки *ok в false, а успех — путём установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с «0x», используется основание 16; если строка начинается с «0», используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toLongLong()

Пример:

QString str = "FF";
bool ok;

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toULongLong(), toInt(), и QLocale::toLongLong().

QString QString::toLower() const

Возвращает копию строки в нижнем регистре.

QString str = "The Qt PROJECT";
str = str.toLower();        // str == "the qt project"

Преобразование регистра всегда происходит в локали 'C'. Для зависящего от локали преобразования в нижний регистр используйте QLocale::toLower()

См. также toUpper() и QLocale::toLower().

[since 5.2] NSString *QString::toNSString() const

Создаёт NSString из QString.

NSString освобождается автоматически.

Примечание: Эта функция доступна только на macOS и iOS.

Эта функция была добавлена в Qt 5.2.

short QString::toShort(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в short с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование завершается неудачно.

Если ok не nullptr, неудача сообщается путём установки *ok в false, а успех — путём установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с «0x», используется основание 16; если строка начинается с «0», используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toShort()

Пример:

QString str = "FF";
bool ok;

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toUShort(), toInt(), и QLocale::toShort().

std::string QString::toStdString() const

Возвращает объект std::string с данными, содержащимися в этом QString. Данные Юникода преобразуются в символы 8-битной кодировки с использованием функции toUtf8().

Этот метод в основном используется для передачи QString функции, которая принимает объект std::string.

См. также toLatin1(), toUtf8(), toLocal8Bit(), и QByteArray::toStdString().

[since 5.5] std::u16string QString::toStdU16String() const

Возвращает объект std::u16string с данными, содержащимися в этом QString. Данные Юникода идентичны данным, возвращаемым методом utf16().

Эта функция была добавлена в Qt 5.5.

См. также utf16(), toStdWString(), и toStdU32String().

[since 5.5] std::u32string QString::toStdU32String() const

Возвращает объект std::u32string с данными, содержащимися в этом QString. Данные Юникода идентичны данным, возвращаемым методом toUcs4().

Эта функция была добавлена в Qt 5.5.

См. также toUcs4(), toStdWString() и toStdU16String().

std::wstring QString::toStdWString() const

Возвращает объект std::wstring с данными, содержащимися в этом QString. std::wstring закодирован в utf16 на платформах, где wchar_t имеет ширину 2 байта (например, Windows), и в ucs4 на платформах, где wchar_t имеет ширину 4 байта (большинство Unix-систем).

Этот метод в основном полезен для передачи QString в функцию, которая принимает объект std::wstring.

См. также utf16(), toLatin1(), toUtf8(), toLocal8Bit(), toStdU16String() и toStdU32String().

uint QString::toUInt(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned int с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование не выполняется.

Если ok не nullptr, ошибка сообщается путем установки *ok в false, а успех - путем установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строк всегда выполняется в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toUInt().

Пример:

QString str = "FF";
bool ok;

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toInt() и QLocale::toUInt().

ulong QString::toULong(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned long с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование не выполняется.

Если ok не nullptr, ошибка сообщается путем установки *ok в false, а успех - путем установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строк всегда выполняется в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toULongLong().

Пример:

QString str = "FF";
bool ok;

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number() и QLocale::toUInt().

qulonglong QString::toULongLong(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned long long с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование не выполняется.

Если ok не nullptr, ошибка сообщается путем установки *ok в false, а успех - путем установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строк всегда выполняется в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toULongLong().

Пример:

QString str = "FF";
bool ok;

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toLongLong() и QLocale::toULongLong().

ushort QString::toUShort(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned short с основанием base, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование не выполняется.

Если ok не nullptr, ошибка сообщается путем установки *ok в false, а успех - путем установки *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строк всегда выполняется в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toUShort().

Пример:

QString str = "FF";
bool ok;

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

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toShort() и QLocale::toUShort().

QList<uint> QString::toUcs4() const

Возвращает представление строки UCS-4/UTF-32 в виде QList<uint>.

UCS-4 — это кодировка Юникода, поэтому она без потерь. Все символы из этой строки будут закодированы в UCS-4. Любая некорректная последовательность кодовых единиц в этой строке заменяется замещающим символом Юникода (QChar::ReplacementCharacter, который соответствует U+FFFD).

Возвращаемый список не завершается символом '\0'.

См. также fromUtf8(), toUtf8(), toLatin1(), toLocal8Bit(), QStringEncoder, fromUcs4() и toWCharArray().

QString QString::toUpper() const

Возвращает копию строки в верхнем регистре.

QString str = "TeXt";
str = str.toUpper();        // str == "TEXT"

Преобразование регистра всегда выполняется в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toUpper().

См. также toLower() и QLocale::toLower().

QByteArray QString::toUtf8() const

Возвращает представление строки в UTF-8 в виде QByteArray.

UTF-8 — это кодировка Юникода и может представлять все символы в строке Юникода, такой как QString.

См. также fromUtf8(), toLatin1(), toLocal8Bit() и QStringEncoder.

qsizetype QString::toWCharArray(wchar_t *array) const

Заполняет array данными, содержащимися в этом объекте QString. Массив закодирован в UTF-16 на платформах, где wchar_t имеет ширину 2 байта (например, Windows), и в UCS-4 на платформах, где wchar_t имеет ширину 4 байта (большинство Unix-систем).

array должен быть выделен вызывающей стороной и содержать достаточно места для хранения всей строки (выделение массива с длиной, равной длине строки, всегда достаточно).

Эта функция возвращает фактическую длину строки в array.

Примечание: Эта функция не добавляет нулевой символ в массив.

См. также utf16(), toUcs4(), toLatin1(), toUtf8(), toLocal8Bit(), toStdWString() и QStringView::toWCharArray().

QString QString::trimmed() const

Возвращает строку, из которой удалены начальные и конечные пробелы.

Пробелы означают любой символ, для которого QChar::isSpace() возвращает true. Это включает ASCII-символы '\t', '\n', '\v', '\f', '\r' и ' '.

Пример:

QString str = "  lots\t of\nwhitespace\r\n ";
str = str.trimmed();
// str == "lots\t of\nwhitespace"

В отличие от simplified(), trimmed() оставляет внутренние пробелы без изменений.

См. также simplified().

void QString::truncate(qsizetype position)

Обрезает строку в заданной позиции position.

Если указанный индекс position выходит за пределы конца строки, ничего не происходит.

Пример:

QString str = "Vladivostok";
str.truncate(4);
// str == "Vlad"

Если position отрицательный, он эквивалентен передаче нуля.

См. также chop(), resize(), first() и QStringView::truncate().

const QChar *QString::unicode() const

Возвращает представление строки в Юникоде. Результат остается действительным до тех пор, пока строка не изменяется.

Примечание: Возвращаемая строка может не завершаться символом '\0'. Используйте size(), чтобы определить длину массива.

См. также setUnicode(), utf16() и fromRawData().

const ushort *QString::utf16() const

Возвращает QString в виде завершаемого символом '\0' массива беззнаковых целых чисел с типом ushort. Результат остается действительным до тех пор, пока строка не изменяется.

Возвращаемая строка находится в порядке байтов хост-машины.

См. также setUtf16() и unicode().

[static, since 5.5] QString QString::vasprintf(const char *cformat, va_list ap)

Эквивалентный метод asprintf(), но принимает va_list ap вместо списка переменных аргументов. См. документацию asprintf() для объяснения cformat.

Этот метод не вызывает макрос va_end, вызывающая сторона отвечает за вызов va_end для ap.

Эта функция была добавлена в Qt 5.5.

См. также asprintf().

bool QString::operator!=(const char *other) const

Эта функция перегружает оператор!=().

Указатель other типа const char преобразуется в QString с помощью функции fromUtf8().

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator!=(const QByteArray &other) const

Эта функция перегружает оператор!=().

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов содержатся символы NULL ('\0'), они будут включены в преобразование.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

QString &QString::operator+=(const QString &other)

Добавляет строку other к концу этой строки и возвращает ссылку на эту строку.

Пример:

QString x = "free";
QString y = "dom";
x += y;
// x == "freedom"

Обычно эта операция выполняется очень быстро (постоянное время), потому что QString предварительно выделяет дополнительное место в конце данных строки, чтобы она могла расти без повторного выделения всей строки каждый раз.

См. также append() и prepend().

QString &QString::operator+=(QChar ch)

Эта функция перегружает оператор+=().

Добавляет символ ch к строке.

[since 6.0] QString &QString::operator+=(QStringView str)

Эта функция перегружает оператор+=().

Добавляет фрагмент строки str к этой строке.

Эта функция была добавлена в Qt 6.0.

QString &QString::operator+=(QLatin1String str)

Эта функция перегружает оператор+=().

Добавляет строку Latin-1 str к этой строке.

QString &QString::operator+=(const char *str)

Эта функция перегружает оператор+=().

Добавляет строку str к этой строке. Указатель const char преобразуется в Unicode с помощью функции fromUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

QString &QString::operator+=(const QByteArray &ba)

Эта функция перегружает оператор+=().

Добавляет массив байтов ba к этой строке. Массив байтов преобразуется в Unicode с помощью функции fromUtf8(). Если в массиве байтов ba содержатся символы NULL ('\0'), они будут включены в преобразование.

Вы можете отключить эту функцию, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator<(const char *other) const

Возвращает true если эта строка лексически меньше строки other. В противном случае возвращает false.

Эта функция перегружает оператор<().

Указатель other типа const char преобразуется в QString с помощью функции fromUtf8().

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator<(const QByteArray &other) const

Эта функция перегружает оператор<().

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов содержатся символы NULL ('\0'), они будут включены в преобразование.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator<=(const char *other) const

Эта функция перегружает оператор<=().

Указатель other типа const char преобразуется в QString с помощью функции fromUtf8().

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator<=(const QByteArray &other) const

Эта функция перегружает оператор<=().

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов содержатся символы NULL ('\0'), они будут включены в преобразование.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

QString &QString::operator=(QChar ch)

Эта функция перегружает оператор=().

Устанавливает строку, содержащую единственный символ ch.

QString &QString::operator=(QLatin1String str)

Эта функция перегружает оператор=().

Присваивает строку Latin-1 str этой строке.

QString &QString::operator=(const char *str)

Эта функция перегружает оператор=().

Присваивает str этой строке. Указатель const char преобразуется в Unicode с помощью функции fromUtf8().

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII или QT_RESTRICTED_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator==(const char *other) const

Эта функция перегружает оператор==().

Указатель other типа const char преобразуется в QString с помощью функции fromUtf8().

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator==(const QByteArray &other) const

Эта функция перегружает оператор==().

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Преобразование прекращается при обнаружении первого символа NULL или по достижении конца массива байтов.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

Возвращает true если эта строка лексически равна строке other. В противном случае возвращает false.

bool QString::operator>(const char *other) const

Эта функция перегружает оператор>().

Указатель other типа const char преобразуется в QString с помощью функции fromUtf8().

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложения. Это может быть полезно, если вы хотите убедиться, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator>(const QByteArray &other) const

Эта функция перегружает оператор>().

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов встроены символы NUL ('\0'), они будут включены в преобразование.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции своих приложений. Это может быть полезно, если вы хотите гарантировать, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator>=(const char *other) const

Эта функция перегружает оператор>=().

Указатель other типа const char преобразуется в QString с помощью функции fromUtf8().

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции своих приложений. Это может быть полезно, если вы хотите гарантировать, что все отображаемые пользователю строки проходят через QObject::tr(), например.

bool QString::operator>=(const QByteArray &other) const

Эта функция перегружает оператор>=().

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов встроены символы NUL ('\0'), они будут включены в преобразование.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции своих приложений. Это может быть полезно, если вы хотите гарантировать, что все отображаемые пользователю строки проходят через QObject::tr(), например.

QChar &QString::operator[](qsizetype position)

Возвращает символ по указанному position в строке в виде изменяемой ссылки.

Пример:

QString str;

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

См. также at().

const QChar QString::operator[](qsizetype position) const

Эта функция перегружает оператор[]().

// hasAttribute takes a QString argument
if (node.hasAttribute("http-contents-length")) //...

if (node.hasAttribute(QStringLiteral(u"http-contents-length"))) //...

if (attribute.name() == QLatin1String("http-contents-length")) //...