Класс QString

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

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

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

Типы

Открытые функции

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

Related Non-Members

Макросы

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

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

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

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

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

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

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

QString str = "Hello";

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

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

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

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

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

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

QString str;
str.resize(4);

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

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

QString str;

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

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

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

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

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

QString str;

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

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

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

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

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

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

У функций replace() и remove() первые два аргумента — позиция, с которой нужно начать удаление, и количество символов, которые нужно удалить. Если вы хотите заменить все вхождения определённой подстроки на другую, используйте одну из перегрузок функции replace() с двумя параметрами.

Часто требуется удалить символы пробелов из строки ('\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 без константности.

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

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

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

Преобразование между кодированными строками и 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("http://www.unicode.org/");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    QString foo;
    QString type = "long";

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

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

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

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

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

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

Дополнительная эффективность достигается благодаря инлайнингу и уменьшению ссылочного подсчета (созданный из QStringBuilder объект QString обычно имеет счетчик ссылок 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 выбросит исключение 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

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

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

перечисление QString::SectionFlagфлаги QString::SectionFlags

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

Тип SectionFlags — это псевдоним для 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

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

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

QString::difference_type

QString::iterator

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

QString::pointer

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

QString::reference

[since 5.6] QString::reverse_iterator

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

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

QString::size_type

QString::value_type

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

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

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

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

за исключением того, что оно работает без включенного в компилятор механизма вывода шаблонов аргументов классов C++17.

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

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

QStringTokenizer result = sv.tokenize(sep);

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

auto result = sv.tokenize(sep);

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

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

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

шаблон <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. Заданный байтовый массив преобразуется в Юникод с помощью fromUtf8(). Копирование прекращается при первом вхождении символа 0, в противном случае копируется весь байтовый массив.

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

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

QString::QString(const char *str)

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

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

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

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

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

Перемещающий конструктор экземпляра QString, который делает его указывающим на тот же объект, на который указывал other.

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

QString::QString(const QString &other)

Создает копию other.

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

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

QString::QString(QLatin1String str)

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

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

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

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

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

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

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

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

Добавляет байтовый массив ba в конец этой строки. Заданный байтовый массив преобразуется в Юникод с помощью функции 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, она дополняется до fieldWidth символом fillChar. Положительное 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 — шестнадцатеричной.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Одно из преимуществ использования 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. Положительное значение fieldWidth приводит к правому выравниванию текста. Отрицательное значение 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 и %s аргументы должны быть закодированы в UTF-8.

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

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

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

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

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

QString::const_iterator QString::begin() const

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

qsizetype QString::capacity() const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void QString::chop(qsizetype n)

Удаляет n символов с конца строки.

Если n больше или равно size(), результатом является пустая строка; если n отрицательно, это эквивалентно передаче нуля.

Пример:

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

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

См. также truncate(), resize(), remove() и QStringView::chop().

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

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

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

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

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

void QString::clear()

Очищает содержимое строки и устанавливает его в пустое значение.

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

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

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

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

Сравнение с учётом регистра основано исключительно на числовых значениях кодов Unicode символов и очень быстрое, но не соответствует ожиданиям человека. Рассмотрите возможность сортировки строк, отображаемых пользователю, с помощью localeAwareCompare().

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

См. также operator==(), operator<(), operator>(), и Сравнение строк.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QString::const_iterator QString::constBegin() const

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

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

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

const QChar *QString::constData() const

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

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

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

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

QString::const_iterator QString::constEnd() const

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

qsizetype QString::count() const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QChar *QString::data()

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

В отличие от constData() и unicode(), возвращаемые данные всегда завершаются '\0'.

Пример:

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

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

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

const QChar *QString::data() const

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

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

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

QString::iterator QString::end()

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

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

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

QString::const_iterator QString::end() const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Устанавливает каждый символ в строке на символ ch. Если size отлично от -1 (по умолчанию), строка предварительно изменяет свой размер до size.

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает QString, инициализированный латинской-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, содержащий копию строки string NSString.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[static, since 6.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'.

Функция проверяет наличие Byte Order Mark (BOM). Если его нет, предполагается порядок байтов хоста.

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

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

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

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

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

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

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

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

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

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

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

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

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

Если заданная position больше, чем size(), эта строка расширяется.

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

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

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

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

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

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

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

Если заданная position больше, чем size(), эта строка расширяется.

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

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

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

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

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

Если заданная position больше, чем size(), эта строка расширяется.

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

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

bool QString::isEmpty() const

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

Пример:

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

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

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

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

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

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

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

bool QString::isNull() const

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

Пример:

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

Qt различает пустые и пустые строки по историческим причинам. Для большинства приложений важно, содержит ли строка данные, и это можно определить с помощью функции isEmpty().

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

bool QString::isRightToLeft() const

Возвращает true, если строка читается справа налево.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

QString QString::left(qsizetype n) const

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

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

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

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

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

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

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

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

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

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

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

qsizetype QString::length() const

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

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

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

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

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

См. также compare(), QLocale, и Comparing Strings.

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

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

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

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

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

См. также Comparing Strings.

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

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

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

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

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

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

См. также Comparing Strings.

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

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

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

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

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

См. также Comparing Strings.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

QString &QString::prepend(QChar ch)

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

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

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

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

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

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

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

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

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

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

QString &QString::prepend(QLatin1String str)

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

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

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

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

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

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

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

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

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

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

void QString::push_back(const QString &other)

Этот метод предоставляется для совместимости со STL, добавляя заданную строку other в конец этой строки. Он эквивалентен append(other).

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

void QString::push_back(QChar ch)

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

Добавляет заданный символ ch в конец этой строки.

void QString::push_front(const QString &other)

Этот метод предоставляется для совместимости со STL, добавляя заданную строку other в начало этой строки. Он эквивалентен prepend(other).

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

void QString::push_front(QChar ch)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QString QString::repeated(qsizetype times) const

Возвращает копию этой строки, повторённой указанное количество times раз.

Если times меньше 1, возвращается пустая строка.

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

QString str = "colour behaviour flavour neighbour";
str.replace(QString("ou"), QString("o"));
// str == "color behavior flavor neighbor"

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

Пример:

QString equis = "xxxxxx";
equis.replace("xx", "x");
// equis == "xxx"

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

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

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

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

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

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

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

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

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

[since 5.0] QString &QString::replace(const QRegularExpression &re, const QString &after)

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

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

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

Для регулярных выражений, содержащих группы захвата, вхождения \1, \2, ..., в after заменяются строкой, захваченной соответствующей группой захвата.

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

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

См. также indexOf(), lastIndexOf(), remove(), QRegularExpression и QRegularExpressionMatch.

void QString::reserve(qsizetype size)

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

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

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

QString result;
int maxSize;
bool condition;
QChar nextChar;

result.reserve(maxSize);

while (condition)
    result.append(nextChar);

result.squeeze();

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

void QString::resize(qsizetype 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().

[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 и размер строки больше width, то возвращаемая строка — копия строки.

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

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

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

QString QString::section(QChar sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

Эта функция возвращает часть строки.

Эта строка рассматривается как последовательность полей, разделенных символом sep. Возвращаемая строка состоит из полей от позиции start до позиции end включительно. Если end не указан, включаются все поля от позиции start до конца строки. Поля нумеруются 0, 1, 2 и т. д., считая слева, и -1, -2 и т. д., считая справа налево.

Аргумент flags может использоваться для изменения некоторых аспектов поведения функции, например, для чувствительности к регистру, пропуска пустых полей и обработки ведущих и хвостовых разделителей; см. SectionFlags.

QString str;
QString csv = "forename,middlename,surname,phone";
QString path = "/usr/local/bin/myapp"; // First field is empty
QString::SectionFlag flag = QString::SectionSkipEmpty;

str = csv.section(',', 2, 2);   // str == "surname"
str = path.section('/', 3, 4);  // str == "bin/myapp"
str = path.section('/', 3, 3, flag); // str == "myapp"

Если start или end отрицательны, мы считаем поля справа от строки, самое правое поле — -1, следующее справа — -2 и так далее.

str = csv.section(',', -3, -2);  // str == "middlename,surname"
str = path.section('/', -1); // str == "myapp"

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

QString QString::section(const QString &sep, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

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

QString str;
QString data = "forename**middlename**surname**phone";

str = data.section("**", 2, 2); // str == "surname"
str = data.section("**", -3, -2); // str == "middlename**surname"

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

[since 5.0] QString QString::section(const QRegularExpression &re, qsizetype start, qsizetype end = -1, QString::SectionFlags flags = SectionDefault) const

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

Эта строка рассматривается как последовательность полей, разделенных регулярным выражением re.

QString line = "forename\tmiddlename  surname \t \t phone";
QRegularExpression sep("\\s+");
str = line.section(sep, 2, 2); // str == "surname"
str = line.section(sep, -3, -2); // str == "middlename  surname"

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

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

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

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

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

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

QString str;
str.setNum(1234);       // str == "1234"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QString &QString::setNum(float n, char format = 'g', int precision = 6)

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

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

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

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

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

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

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

format может быть 'e', 'E', 'f', 'g' или 'G' (см. Форматы аргументов для объяснения форматов).

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

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

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

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

Этот метод можно использовать вместо fromRawData() для повторного использования существующих объектов QString, чтобы сохранить перераспределение памяти.

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

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

Изменяет размер строки на size символов и копирует unicode в строку.

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

См. также unicode() и setUtf16().

QString &QString::setUtf16(const ushort *unicode, qsizetype size)

Изменяет размер строки на size символов и копирует unicode в строку.

Если unicode равен 0, ничего не копируется, но размер строки всё равно изменяется на 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";
int n = str.size();         // n == 5
str.data()[0];              // returns 'W'
str.data()[4];              // returns 'd'

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

[since 6.0] QString QString::sliced(qsizetype pos, qsizetype n) const

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

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

QString x = "Nine pineapples";
QString y = x.sliced(5, 4);            // y == "pine"
QString z = x.sliced(5);               // z == "pineapples"

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

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

[since 6.0] QString QString::sliced(qsizetype pos) const

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

Возвращает строку, содержащую часть этой строки, начинающуюся с позиции pos и продолжающуюся до её конца.

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

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

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

[since 5.14] QStringList QString::split(const QString &sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Разделяет строку на подстроки там, где встречается sep, и возвращает список этих строк. Если sep не совпадает нигде в строке, split() возвращает список из одной строки, содержащей эту строку.

cs указывает, будет ли sep сравниваться с учётом регистра или без учёта регистра.

Если behavior равно Qt::SkipEmptyParts, пустые элементы не отображаются в результате. По умолчанию пустые элементы сохраняются.

Пример:

QString str = QStringLiteral("a,,b,c");

QStringList list1 = str.split(QLatin1Char(','));
// list1: [ "a", "", "b", "c" ]

QStringList list2 = str.split(QLatin1Char(','), Qt::SkipEmptyParts);
// list2: [ "a", "b", "c" ]

Если sep пустая, split() возвращает пустую строку, за которой следуют каждый символ строки, а за ним — ещё одна пустая строка:

QString str = "abc";
auto parts = str.split(QString());
// parts: {"", "a", "b", "c", ""}

Чтобы понять это поведение, вспомните, что пустая строка совпадает повсюду, поэтому вышеизложенное качественно аналогично:

QString str = "/a/b/c/";
auto parts = str.split(QLatin1Char('/'));
// parts: {"", "a", "b", "c", ""}

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

См. также QStringList::join() и section().

[since 5.14] QStringList QString::split(QChar sep, Qt::SplitBehavior behavior = Qt::KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

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

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

[since 5.14] QStringList QString::split(const QRegularExpression &re, Qt::SplitBehavior behavior = Qt::KeepEmptyParts) const

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

Разделяет строку на подстроки там, где соответствует регулярное выражение re, и возвращает список этих строк. Если re не соответствует нигде в строке, split() возвращает список из одной строки, содержащей эту строку.

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

QString str;
QStringList list;

str = "Some  text\n\twith  strange whitespace.";
list = str.split(QRegularExpression("\\s+"));
// list: [ "Some", "text", "with", "strange", "whitespace." ]

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

str = "This time, a normal English sentence.";
list = str.split(QRegularExpression("\\W+"), Qt::SkipEmptyParts);
// list: [ "This", "time", "a", "normal", "English", "sentence" ]

Вот третий пример, где мы используем утверждение нулевой длины \b (граница слова), чтобы разделить строку на чередующуюся последовательность несловообразующих и словообразующих токенов:

str = "Now: this sentence fragment.";
list = str.split(QRegularExpression("\\b"));
// list: [ "", "Now", ": ", "this", " ", "sentence", " ", "fragment", "." ]

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

См. также QStringList::join() и section().

void QString::squeeze()

Освобождает любую память, не необходимую для хранения данных символов.

Единственная цель этого метода — предоставить средство для тонкой настройки использования памяти QString. В целом, вам редко придётся вызывать этот метод.

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

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

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

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

QString str = "Bananas";
str.startsWith("Ban");     // returns true
str.startsWith("Car");     // returns false

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

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

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

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

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

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

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

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

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

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

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

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

void QString::swap(QString &other)

Меняет местами строку other с этой строкой. Эта операция очень быстрая и никогда не терпит неудачу.

[since 5.2] CFStringRef QString::toCFString() const

Создаёт CFString из QString.

Вызывающая сторона владеет CFString и отвечает за его освобождение.

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

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

QString QString::toCaseFolded() const

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

double QString::toDouble(bool *ok = nullptr) const

Возвращает строку, преобразованную в значение double.

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

Если ok не nullptr, неудача сообщается установкой *ok в false, а успех – в true.

QString str = "1234.56";
double val = str.toDouble();   // val == 1234.56

Предупреждение: Содержимое QString должно содержать только допустимые числовые символы, включая знак плюс/минус, символ e для научной записи и десятичную точку. Включение единиц или дополнительных символов приводит к ошибке преобразования.

bool ok;
double d;

d = QString( "1234.56e-02" ).toDouble(&ok); // ok == true, d == 12.3456

d = QString( "1234.56e-02 Volt" ).toDouble(&ok); // ok == false, d == 0

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toDouble()

d = QString( "1234,56" ).toDouble(&ok); // ok == false
d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56

По историческим причинам эта функция не обрабатывает разделители тысяч. Если вам нужно преобразовать такие числа, используйте QLocale::toDouble().

d = QString( "1,234,567.89" ).toDouble(&ok); // ok == false
d = QString( "1234567.89" ).toDouble(&ok); // ok == true

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), QLocale::setDefault(), QLocale::toDouble(), и trimmed().

float QString::toFloat(bool *ok = nullptr) const

Возвращает строку, преобразованную в значение float.

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

Если ok не nullptr, неудача сообщается установкой *ok в false, а успех – в true.

Предупреждение: Содержимое QString должно содержать только допустимые числовые символы, включая знак плюс/минус, символ e для научной записи и десятичную точку. Включение единиц или дополнительных символов приводит к ошибке преобразования.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toFloat()

По историческим причинам эта функция не обрабатывает разделители тысяч. Если вам нужно преобразовать такие числа, используйте QLocale::toFloat().

Пример:

QString str1 = "1234.56";
str1.toFloat();             // returns 1234.56

bool ok;
QString str2 = "R2D2";
str2.toFloat(&ok);          // returns 0.0, sets ok to false

QString str3 = "1234.56 Volt";
str3.toFloat(&ok);          // returns 0.0, sets ok to false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toDouble(), toInt(), QLocale::toFloat(), и trimmed().

[since 5.0] QString QString::toHtmlEscaped() const

Преобразует обычную текстовую строку в HTML-строку, заменяя HTML-специальные символы <, >, & и " соответствующими HTML-сущностями.

Пример:

QString plain = "#include <QtCore>"
QString html = plain.toHtmlEscaped();
// html == "#include &lt;QtCore&gt;"

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

int QString::toInt(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в целое число с основанием base (по умолчанию 10) и значением от 2 до 36 или 0. Возвращает 0, если преобразование терпит неудачу.

Если ok не nullptr, неудача сообщается установкой *ok в false, а успех – в 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

Возвращает латинскую-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, а успех – в 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, а успех – в true.

Если base равно 0, используется соглашение C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toLongLong()

Пример:

QString str = "FF";
bool ok;

qint64 hex = str.toLongLong(&ok, 16);      // hex == 255, ok == true
qint64 dec = str.toLongLong(&ok, 10);      // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toULongLong(), toInt(), и QLocale::toLongLong().

QString QString::toLower() const

Возвращает копию строки в нижнем регистре.

QString str = "The Qt PROJECT";
str = str.toLower();        // str == "the qt project"

Преобразование регистра всегда происходит в локали 'C'. Для преобразования регистра, зависящего от локали, используйте QLocale::toLower()

См. также toUpper() и QLocale::toLower().

[since 5.2] NSString *QString::toNSString() const

Создаёт NSString из QString.

NSString автоматически освобождается.

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

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

short QString::toShort(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в short с основанием base (по умолчанию 10) и значением от 2 до 36 или 0. Возвращает 0, если преобразование терпит неудачу.

Если ok не nullptr, неудача сообщается установкой *ok в false, а успех – в 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 закодирован в UTF-16 на платформах, где wchar_t имеет ширину 2 байта (например, Windows), и в UCS-4 на платформах, где 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

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

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

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

const ushort *QString::utf16() const

Возвращает QString как массив беззнаковых целых чисел типа ushort, завершённый символом '\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)

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

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

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

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

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

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

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Эта функция останавливает преобразование при первом найденном нулевом символе или конце массива байтов.

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

Возвращает true, если эта строка лексически равна строке параметра other. В противном случае возвращает false.

bool QString::operator>(const char *other) const

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

Указатель const char other преобразуется в 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(), например.

bool QString::operator>=(const char *other) const

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

Указатель const char other преобразуется в 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(), например.

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

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

Пример:

QString str;

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

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

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

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

// hasAttribute takes a QString argument
if (node.hasAttribute("http-contents-length")) //...

if (node.hasAttribute(QStringLiteral(u"http-contents-length"))) //...

if (attribute.name() == QLatin1String("http-contents-length")) //...