Класс QString

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

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

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

Типы

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

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

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

Макросы

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

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

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

Внутри QString используется неявное совместное использование (копирование при записи) для уменьшения использования памяти и предотвращения ненужного копирования данных. Это также помогает уменьшить издержки, связанные с хранением 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.

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

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") {
    // ...
}

Вы также можете передавать строковые литералы функциям, принимающим QString в качестве аргумента, вызывая конструктор 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++.

Частой задачей является удаление пробельных символов из строки ('\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. Указатель гарантированно остаётся действительным до тех пор, пока не будет вызвана функция QString, отличная от const.

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

QString можно сравнивать, используя перегруженные операторы, такие как 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() возвращает строку, закодированную в Latin-1 (ISO 8859-1), 8-битного типа.
• toUtf8() возвращает строку, закодированную в UTF-8, 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("https://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 различает пустую строку и строку со значением null. Строка null — это строка, которая инициализируется с помощью конструктора QString по умолчанию или путём передачи (const char *)0 в конструктор. Строка пустая — это любая строка с размером 0. Строка null всегда пустая, но пустая строка не обязательно null:

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(), обрабатывают строки null так же, как пустые строки. Например, toUtf8().constData() возвращает действительный указатель (не nullptr) на символ '\0' для строки null.

Рекомендуется всегда использовать функцию isEmpty() и избегать isNull().

Форматы чисел

Когда в спецификаторе форматирования QString::arg() '%' включается квалификатор локали 'L', а основание равно десяти (по умолчанию), используется локаль по умолчанию. Её можно установить с помощью QLocale::setDefault(). Для более точного управления локальными строковыми представлениями чисел, см. QLocale::toString(). Всё остальное форматирование чисел в QString соответствует представлению чисел в C-локали.

Когда QString::arg() применяет левое выравнивание к числам, символ заполнения '0' обрабатывается особым образом. Если число отрицательное, его знак минус будет отображаться перед нулевым заполнением. Если поле локализовано, в качестве нулевого символа используется символ, соответствующий локали, вместо '0'. Для чисел с плавающей точкой это специальное обращение применяется только если число конечно.

Форматы чисел с плавающей точкой

В методах-членах (например, arg(), number()), которые представляют числа с плавающей точкой (float или double) в виде строк, форму отображения можно контролировать с помощью выбора формата и точности, смысл которых аналогичен QLocale::toString(double, char, int).

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

Более эффективное создание строк

Многие строки известны во время компиляции. Но тривиальный конструктор 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.

Перечисление QString::NormalizationForm

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

См. также normalized() и Unicode Standard Annex #15.

Перечисление QString::SectionFlagflags QString::SectionFlags

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

Тип SectionFlags — это typedef для QFlags<SectionFlag>. Он хранит комбинацию значений SectionFlag с помощью операции OR.

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

Этот typedef был введён в 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

Этот typedef был введён в 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 вывода шаблонов аргументов классов (CTAD).

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

QStringTokenizer result = sv.tokenize(sep);

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

auto result = sv.tokenize(sep);

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

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

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

[since 5.14] 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(), например.

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

Создаёт копию латинской-1 строки 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', и его длина определяется динамически. Завершающий нулевой символ не считается частью строки.

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

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

QString::QString()

Создаёт пустую строку. Пустые строки также являются пустыми.

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

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

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

Присваивает ba этой строке. Байтовый массив преобразуется в Unicode с помощью функции fromUtf8(). Эта функция прекращает преобразование на первом найденном нулевом символе или в конце байтового массива 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().

Добавляет латинскую строку 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 создаёт выравнивание текста по левому краю.

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

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 — шестнадцатеричное.

См. также Форматы чисел.

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

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

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

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

См. также Форматы чисел.

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"

См. также Форматы чисел.

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 — шестнадцатеричное.

См. также Форматы чисел.

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(). Если локаль по умолчанию не указана, используется системная локаль.

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"

См. также Форматы чисел.

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

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

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

См. также Форматы чисел.

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 — шестнадцатеричной системе счисления.

См. также Форматы чисел.

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 — шестнадцатеричной системе счисления.

См. также Форматы чисел.

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. Положительное значение приводит к выравниванию текста по правому краю; отрицательное — по левому.

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

См. также QLocale::toString(), QLocale::FloatingPointPrecisionOption и Форматы чисел.

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

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

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

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

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

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

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

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

Во-первых, arg(i) заменяет %1. Затем arg(total) заменяет %2. Наконец, arg(fileName) заменяет %3.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const QChar QString::at(qsizetype position) const

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

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

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

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

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

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

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

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

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

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

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

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

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

QString::iterator QString::begin()

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

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

QString::const_iterator QString::begin() const

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

qsizetype QString::capacity() const

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

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

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

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

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

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

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

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

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

Эта функция была добавлена в 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 левых символов этой строки.

Эта функция была добавлена в 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, сравнение выполняется регистрозависимо; в противном случае сравнение выполняется регистронезависимо.

Регистрозависимое сравнение основано исключительно на числовых значениях Юникода символов и очень быстрое, но не то, чего ожидает человек. Рассмотрите сортировку строк, видимых пользователю, с помощью 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 и возвращает целое число меньше, равно или больше нуля, если эта строка меньше, равна или больше строки 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, указывающий на первый символ в строке.

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

const QChar *QString::constData() const

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

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

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

QString::const_iterator QString::constEnd() const

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

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

По историческим причинам эта функция считает перекрывающиеся совпадения, поэтому в примере ниже имеется четыре экземпляра "ana" или "ama":

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

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

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

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

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

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

Эта функция была добавлена в 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

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

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

QString::iterator QString::end()

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

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

QString::const_iterator QString::end() const

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

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

Возвращает 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 символов этой строки.

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.

Данная функция была введена в 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.

Данная функция была введена в 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) {
    // ...
}

См. также 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, инициализированную строкой str в кодировке UTF-8.

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

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

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

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

Функция была добавлена в 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 (кодировка 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()). Для получения дополнительной информации см. стандарт Юникод, раздел 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()). Для получения дополнительной информации см. стандарт Юникод, раздел 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 символов этой строки.

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, 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.

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

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

Возвращает позицию индекса последнего вхождения строки str в этой строке. Возвращает -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

Данная функция была введена в Qt 6.2.

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

qsizetype QString::lastIndexOf(QLatin1String str, qsizetype from, 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 6.2] qsizetype QString::lastIndexOf(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

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

Возвращает индекс последнего вхождения строки str в этой строке. Возвращает -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

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

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

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

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

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

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

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

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

[since 5.14] qsizetype QString::lastIndexOf(QStringView str, qsizetype from, 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 6.2] qsizetype QString::lastIndexOf(const QRegularExpression &re, QRegularExpressionMatch *rmatch = nullptr) const

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

Возвращает индекс последнего совпадения регулярного выражения re в строке. Возвращает -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

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

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

Возвращает индекс последнего совпадения регулярного выражения re в строке, которое начинается перед индексом from. Если from равно -1, поиск начинается с последнего символа; если from равно -2, с предпоследнего символа и так далее. Возвращает -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

Эта функция была добавлена в 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 и размер() строки больше width, возвращаемая строка является копией строки.

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

Если truncate равно true и размер() строки больше 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 превышает длину строки. Если в строке, начиная с заданного position, доступно меньше, чем n символов, или если n равно -1 (значение по умолчанию), функция возвращает все доступные символы, начиная с указанного position.

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

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

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

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

Возвращает строку, эквивалентную числу n в соответствии с указанным основанием base.

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

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

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

QString QString::number(int n, int base = 10)

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

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

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

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

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

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

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

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

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

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

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

Возвращает строку, представляющую n, отформатированную в соответствии с указанным format и precision.

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

См. также setNum(), QLocale::toString(), QLocale::FloatingPointPrecisionOption и Форматы чисел.

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

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

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

Пример:

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

QString &QString::prepend(QChar ch)

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

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

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

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

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

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

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 преобразуется в Юникод с помощью функции fromUtf8().

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

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

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

Добавляет массив байтов ba в начало этой строки. Массив байтов преобразуется в Юникод с помощью функции 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 в начало этой строки.

QString::reverse_iterator QString::rbegin()

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

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

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

QString::const_reverse_iterator QString::rbegin() const

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

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

QString &QString::remove(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, указывающий сразу после последнего символа в строке в обратном порядке.

Эта функция была введена в 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 и возвращает ссылку на эту строку.

Пример:

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 является недооценкой, строка будет расти по мере необходимости, когда зарезервированный размер будет превышен, что может привести к выделению памяти больше, чем ваша самая большая переоценка, и замедлит операцию, которая её вызовет.

Эта функция полезна для кода, которому нужно построить длинную строку и который хочет избежать многократного перераспределения. В этом примере мы хотим добавлять в строку, пока не выполнится некоторое условие 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 исключаются из строки.

Пример:

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

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

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

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

Если truncate истинно и 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"

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

См. также split() и simplified().

QString &QString::setNum(int n, int base = 10)

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

По умолчанию base = 10, должно быть в диапазоне от 2 до 36.

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, и возвращает ссылку на строку.

См. также number(), QLocale::FloatingPointPrecisionOption и Форматы чисел.

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

Сбрасывает QString на использование первых size символов Юникода в массиве 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.

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 и до конца.

Эта функция была добавлена в 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 и отвечает за его освобождение.

Эта функция была представлена в 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

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.

Преобразование строки всегда происходит в локале '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.

Возвращаемый массив байтов не определён, если строка содержит символы, не являющиеся Latin-1. Эти символы могут быть подавлены или заменены вопросительным знаком.

См. также 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 освобождается автоматически.

Эта функция была добавлена в 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

Возвращает представление строки в Юникоде. Результат остаётся действительным до изменения строки.

См. также setUnicode(), utf16() и fromRawData().

const ushort *QString::utf16() const

Возвращает QString как завершаемый символом '\0' массив целых без знака. Результат остаётся действительным до изменения строки.

Возвращаемая строка в порядке байтов хоста.

См. также 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(). Если в массиве байтов встроены нулевые символы ('\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)

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

Добавляет латин-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)

Присваивает латинскую строку 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(). Если в массиве байтов содержатся символы 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(), например.

QChar &QString::operator[](qsizetype position)

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

Пример:

QString str;

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

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

const QChar QString::operator[](qsizetype position) const

Перегружает оператор [].

auto str = u"hello"_qs;