Класс QString

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

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

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

Типы публичного доступа

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

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

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

Макросы

Detailed Description

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

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

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

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

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

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

QString str = "Hello";

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

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

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

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

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

Другой подход заключается в установке размера строки с помощью resize() и инициализации данных посимвольно. QString использует индексы, начинающиеся с 0, как и массивы 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 (int 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[](), потому что она никогда не приводит к созданию глубокой копии. В качестве альтернативы используйте функции left(), right() или mid() для извлечения нескольких символов за раз.

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 и заранее знаете приблизительное количество символов в 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>";
int 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(). Вы можете получить список строк из списка строк, содержащих определенную подстроку или соответствующих определенному QRegExp, используя функцию QStringList::filter().

Запрос данных строки

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

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

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

Преобразование между 8-разрядными строками и строками Юникода

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

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

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

Как упоминалось выше, 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.

Один из способов определения этих препроцессорных символов глобально для вашего приложения — добавить следующую запись в файл проекта qmake:

DEFINES += QT_NO_CAST_FROM_ASCII \
           QT_NO_CAST_TO_ASCII

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

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

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

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

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

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

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

Более эффективные методы построения строк

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

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

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

    QString foo;
    QString type = "long";

    foo->setText(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");
    QStringRef el(&hello, 2, 3);
    QLatin1String world("world");
    QString message =  hello % el % world % QChar('!');

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

    DEFINES *= QT_USE_QSTRINGBUILDER

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

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

Текущая версия QString ограничена примерно 2 ГБ (2³¹ байт) размером. Точное значение зависит от архитектуры, так как оно зависит от накладных расходов, необходимых для управления блоком данных, но не превышает 32 байта. Блоки необработанных данных также ограничены использованием типа int в текущей версии до 2 ГБ минус 1 байт. Поскольку QString использует два байта на символ, это означает чуть меньше 2³⁰ символов в одном QString.

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

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

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

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

typedef QString::ConstIterator

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

typedef QString::Iterator

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

enum QString::NormalizationForm

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

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

enum QString::SectionFlagflags QString::SectionFlags

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

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

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

enum QString::SplitBehavior

Этот перечисление определяет, как функция split() должна вести себя по отношению к пустым строкам.

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

typedef QString::const_iterator

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

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

typedef QString::const_pointer

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

typedef QString::const_reference

Этот псевдоним предоставляет ссылку const в стиле STL для элемента QString (QChar).

typedef QString::const_reverse_iterator

Этот псевдоним предоставляет обратный итератор const в стиле STL для QString.

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

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

typedef QString::difference_type

Псевдоним QString::size_type предоставляет тип в стиле STL для разницы между указателями.

typedef QString::iterator

Псевдоним QString::iterator предоставляет итератор non-const в стиле STL для QString.

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

typedef QString::pointer

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

typedef QString::reference

Этот псевдоним предоставляет ссылку в стиле STL для элемента QString (QChar).

typedef QString::reverse_iterator

Этот псевдоним предоставляет обратный итератор non-const в стиле STL для QString.

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

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

typedef QString::size_type

Псевдоним QString::size_type предоставляет тип в стиле STL для размеров (int).

typedef QString::value_type

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

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

QString::QString(const QByteArray &ba)

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

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

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

QString::QString(const char *str)

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

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

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

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

QString::QString(QString &&other)

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

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

QString::QString(const QString &other)

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

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

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

QString::QString(QLatin1String str)

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

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

QString::QString(int size, QChar ch)

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

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

QString::QString(QChar ch)

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

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

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

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

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

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

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

QString::QString()

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

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

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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 к этой строке.

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

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

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

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

QString &QString::append(const QStringRef &reference)

Добавляет заданную строку reference к этой строке и возвращает результат.

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

QString &QString::append(QLatin1String str)

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

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

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

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

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

fieldWidth задаёт минимальное количество символов, занимаемых a. Если a занимает меньше места, чем fieldWidth, она дополняется символом fillChar до 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.

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

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

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

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

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

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

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

QString QString::arg(const QString &a1, const QString &a2) const

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

Это то же самое, что и str.arg(a1).arg(a2), за исключением того, что строки a1 и a2 заменяются за один проход. Это может иметь значение, если a1 содержит, например, %1:

QString str;
str = "%1 %2";

str.arg("%1f", "Hello");        // returns "%1f Hello"
str.arg("%1f").arg("Hello");    // returns "Hellof %2"

Аналогичная проблема возникает, когда маркированные позиции не разделены пробелами:

QString str;
str = "%1%3%2";
str.arg("Hello").arg(20).arg(50); // returns "Hello500"

str = "%1%2%3";
str.arg("Hello").arg(50).arg(20); // returns "Hello5020"

Давайте рассмотрим подстановки:

• Во-первых, Hello заменяет %1, так что строка становится "Hello%3%2".
• Затем, 20 заменяет %2, так что строка становится "Hello%320".
• Поскольку максимальное значение маркированной позиции равно 99, 50 заменяет %32.

Таким образом, строка окончательно становится "Hello500".

В таких случаях следующее даёт ожидаемые результаты:

QString str;
str = "%1%3%2";
str.arg("Hello", QString::number(20), QString::number(50)); // returns "Hello5020"

QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const

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

Это то же самое, что вызов str.arg(a1).arg(a2).arg(a3), за исключением того, что строки a1, a2 и a3 заменяются за один проход.

QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4) const

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

Это то же самое, что вызов str.arg(a1).arg(a2).arg(a3).arg(a4), за исключением того, что строки a1, a2, a3 и a4 заменяются за один проход.

QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5) const

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

Это то же самое, что вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5), за исключением того, что строки a1, a2, a3, a4 и a5 заменяются за один проход.

QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5, const QString &a6) const

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

Это то же самое, что вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6)), за исключением того, что строки a1, a2, a3, a4, a5 и a6 заменяются за один проход.

QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5, const QString &a6, const QString &a7) const

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

Это то же самое, что вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7), за исключением того, что строки a1, a2, a3, a4, a5, a6 и a7 заменяются за один проход.

QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5, const QString &a6, const QString &a7, const QString &a8) const

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

Это то же самое, что вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8), за исключением того, что строки a1, a2, a3, a4, a5, a6, a7 и a8 заменяются за один проход.

QString QString::arg(const QString &a1, const QString &a2, const QString &a3, const QString &a4, const QString &a5, const QString &a6, const QString &a7, const QString &a8, const QString &a9) const

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

Это то же самое, что вызов str.arg(a1).arg(a2).arg(a3).arg(a4).arg(a5).arg(a6).arg(a7).arg(a8).arg(a9), за исключением того, что строки a1, a2, a3, a4, a5, a6, a7, a8 и a9 заменяются за один проход.

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

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

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

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

const QChar QString::at(int position) const

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

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

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

QChar QString::back() const

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

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

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

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

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

QCharRef QString::back()

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

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

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

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

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

QString::iterator QString::begin()

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

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

QString::const_iterator QString::begin() const

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

int QString::capacity() const

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

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

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

QString::const_iterator QString::cbegin() const

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

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

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

QString::const_iterator QString::cend() const

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

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

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

void QString::chop(int n)

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

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

Пример:

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

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

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

QString QString::chopped(int len) const

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

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

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

См. также endsWith(), left(), right(), mid(), chop() и truncate().

void QString::clear()

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

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

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

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

Если cs равен Qt::CaseSensitive, сравнение чувствительно к регистру; в противном случае сравнение нечувствительно к регистру.

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

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

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

См. также operator==(), operator<() и operator>().

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

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

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

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

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

int QString::compare(const QStringRef &ref, Qt::CaseSensitivity cs = ...) const

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

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

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

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

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

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

int QString::compare(QStringView s, Qt::CaseSensitivity cs = ...) const

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

Производит сравнение текущей строки с s, используя настройку чувствительности к регистру cs.

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

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

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

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

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

int QString::compare(QLatin1String s1, const QString &s2, Qt::CaseSensitivity cs = ...)

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

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

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

int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs = ...)

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

QString::const_iterator QString::constBegin() const

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

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

const QChar *QString::constData() const

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

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

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

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

QString::const_iterator QString::constEnd() const

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

bool QString::contains(QLatin1String str, Qt::CaseSensitivity cs = ...) const

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

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

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

bool QString::contains(QStringView str, Qt::CaseSensitivity cs = ...) const

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

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

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

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

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

bool QString::contains(const QRegExp &rx) const

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

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

bool QString::contains(QRegExp &rx) const

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

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

Если совпадение найдено, регулярное выражение rx будет содержать сопоставленные группы (см. QRegExp::matchedLength, QRegExp::cap).

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

bool QString::contains(const QRegularExpression &re) const

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

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

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

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

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

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

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

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

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

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

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

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

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

int QString::count() const

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

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

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

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

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

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

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

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

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

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

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

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

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

int QString::count(const QRegExp &rx) const

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

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

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

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

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

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

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

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

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

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

QString::const_reverse_iterator QString::crbegin() const

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

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

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

QString::const_reverse_iterator QString::crend() const

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

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

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

QChar *QString::data()

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

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

Пример:

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

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

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

const QChar *QString::data() const

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

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

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

QString::iterator QString::end()

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

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

QString::const_iterator QString::end() const

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

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

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

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

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

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

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

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

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

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

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

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

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, int size = -1)

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

Пример:

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

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

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

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

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

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

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

[static] QString QString::fromLatin1(const char *str, int size = -1)

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

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

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

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

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

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

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

[static] QString QString::fromLocal8Bit(const char *str, int size = -1)

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

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

Для преобразования используется QTextCodec::codecForLocale().

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

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

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

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

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

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

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

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

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

[static] QString QString::fromRawData(const QChar *unicode, int 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] QString QString::fromStdU16String(const std::u16string &str)

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

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

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

[static] 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. Предполагается, что данная строка закодирована в UTF-16, если размер wchar_t равен 2 байтам (например, в Windows), и в UCS-4, если размер wchar_t равен 4 байтам (большинство систем Unix).

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

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

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

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

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

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

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

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

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

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

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

[static] QString QString::fromUtf8(const char *str, int size = -1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QChar QString::front() const

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

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

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

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

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

QCharRef QString::front()

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

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

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

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

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

int QString::indexOf(QLatin1String str, int 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, со второго с конца и так далее.

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

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

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

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

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

int QString::indexOf(const QString &str, int 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().

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

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

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

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

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

int QString::indexOf(QStringView str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

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

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

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

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

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

int QString::indexOf(const QRegExp &rx, int from = 0) const

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

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

Пример:

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

int QString::indexOf(QRegExp &rx, int from = 0) const

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

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

Если совпадение найдено, регулярное выражение rx будет содержать совпавшие захваты (см. QRegExp::matchedLength, QRegExp::cap).

Пример:

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

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

int QString::indexOf(const QRegularExpression &re, int from = 0) const

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

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

Пример:

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

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

int QString::indexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const

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

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

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

Пример:

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

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

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

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

Пример:

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

Если заданный position больше, чем size(), массив сначала расширяется с помощью resize().

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

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

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

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

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

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

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

QString &QString::insert(int position, const QStringRef &str)

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

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

Если заданный position больше, чем size(), массив сначала расширяется с помощью resize().

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

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

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

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

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

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

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

Если заданный position больше, чем size(), массив сначала расширяется с помощью resize().

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

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

Если заданный position больше, чем size(), массив сначала расширяется с помощью resize().

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::isEmpty() const

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

Пример:

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

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

bool QString::isLower() const

Возвращает 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, если строка читается справа налево.

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

bool QString::isUpper() const

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

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

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

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

int QString::lastIndexOf(const QString &str, int 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().

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

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

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

int QString::lastIndexOf(QLatin1String str, int 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

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

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

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

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

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

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

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

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

int QString::lastIndexOf(QStringView str, int 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().

int QString::lastIndexOf(const QRegExp &rx, int from = -1) const

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

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

Пример:

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

int QString::lastIndexOf(QRegExp &rx, int from = -1) const

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

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

Если совпадение найдено, регулярное выражение rx будет содержать соответствующие подстроки (см. QRegExp::matchedLength, QRegExp::cap).

Пример:

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

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

int QString::lastIndexOf(const QRegularExpression &re, int from = -1) const

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

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

Пример:

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

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

int QString::lastIndexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const

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

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

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

Пример:

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

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

QString QString::left(int n) const

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

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

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

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

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

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

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

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

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

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

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

QStringRef QString::leftRef(int n) const

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

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

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

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

См. также left(), rightRef(), midRef() и startsWith().

int QString::length() const

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

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

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

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

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

В macOS и iOS эта функция сравнивает строки согласно настройкам «Порядок для отсортированных списков» в панели «Международные настройки».

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

См. также left(), right(), chopped(), chop() и truncate().

QStringRef QString::midRef(int position, int n = -1) const

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

Если position превышает длину строки, возвращается нулевая ссылка.

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

Пример:

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

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

См. также mid(), leftRef() и rightRef().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

QString &QString::prepend(QChar ch)

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

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

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

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

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

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

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

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

void QString::push_back(const QString &other)

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

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

void QString::push_back(QChar ch)

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

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

void QString::push_front(const QString &other)

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

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

void QString::push_front(QChar ch)

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

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

QString::reverse_iterator QString::rbegin()

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

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

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

QString::const_reverse_iterator QString::rbegin() const

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

QString &QString::remove(const QRegExp &rx)

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

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

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

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

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

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

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

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

QString::reverse_iterator QString::rend()

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

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

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

QString::const_reverse_iterator QString::rend() const

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

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

QString QString::repeated(int times) const

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

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

Пример:

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

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

QString &QString::replace(int position, int 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(int position, int n, QChar after)

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

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

QString &QString::replace(int position, int n, const QChar *unicode, int 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, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 (по умолчанию), поиск выполняется с учётом регистра; в противном случае — без учёта регистра.

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

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

QString &QString::replace(const QRegExp &rx, const QString &after)

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

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

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

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

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

См. также indexOf(), lastIndexOf(), remove(), и QRegExp::cap().

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(int 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(int 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(int, QChar).

Если вы хотите расширить строку до определенной ширины и заполнить новые позиции определённым символом, используйте функцию leftJustified():

Если size отрицательное, это эквивалентно передаче нуля.

QString r = "Hello";
r = r.leftJustified(10, ' ');
// r == "Hello     "

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

void QString::resize(int size, QChar fillChar)

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

В отличие от resize(int), этот перегруз инициализирует новые символы значением fillChar:

QString t = "Hello";
r.resize(t.size() + 10, 'X');
// t == "HelloXXXXXXXXXX"

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

QString QString::right(int n) const

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

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

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

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

QString QString::rightJustified(int 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().

QStringRef QString::rightRef(int n) const

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

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

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

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

См. также right(), leftRef(), midRef() и endsWith().

QString QString::section(QChar sep, int start, int end = ..., 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, int start, int 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().

QString QString::section(const QRegExp &reg, int start, int end = -1, QString::SectionFlags flags = SectionDefault) const

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

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

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

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

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

QString QString::section(const QRegularExpression &re, int start, int 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 и возвращает ссылку на строку.

Значение 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, int size)

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

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что в отличие от fromUtf16(), эта функция не учитывает BOM и, возможно, различные порядки байтов.

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

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

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

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

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

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

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

Пример:

QString str = "a,,b,c";

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

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

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

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

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

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

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

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

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

QStringList QString::split(const QRegExp &rx, QString::SplitBehavior behavior = KeepEmptyParts) const

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

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

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

QString str;
QStringList list;

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

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

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

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

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

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

QStringList QString::split(const QRegularExpression &re, QString::SplitBehavior behavior = 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+"), QString::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.0.

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

QVector<QStringRef> QString::splitRef(const QString &sep, QString::SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

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

См. QString::split() для того, как sep, behavior и cs взаимодействуют, чтобы сформировать результат.

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

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

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

QVector<QStringRef> QString::splitRef(QChar sep, QString::SplitBehavior behavior = KeepEmptyParts, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

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

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

QVector<QStringRef> QString::splitRef(const QRegExp &rx, QString::SplitBehavior behavior = KeepEmptyParts) const

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

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

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

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

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

QVector<QStringRef> QString::splitRef(const QRegularExpression &re, QString::SplitBehavior behavior = KeepEmptyParts) const

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

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

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

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

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

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

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

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

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

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

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

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 с этой строкой. Эта операция очень быстрая и никогда не терпит неудачу.

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

CFStringRef QString::toCFString() const

Создаёт CFString из QString. Вызывающий код владеет CFString и отвечает за его освобождение.

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

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

QString QString::toCaseFolded() const

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

double QString::toDouble(bool *ok = nullptr) const

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

Возвращает бесконечность, если преобразование переполняет, или 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

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

Возвращает бесконечность, если преобразование переполняет, или 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().

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

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

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

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

QByteArray QString::toLocal8Bit() const

Возвращает локальное 8-битное представление строки в формате QByteArray. Возвращаемый массив байтов не определён, если строка содержит символы, не поддерживаемые локальным 8-битным кодированием.

QTextCodec::codecForLocale() используется для выполнения преобразования из Юникода. Если кодировка локали не может быть определена, эта функция делает то же самое, что и toLatin1().

Если эта строка содержит символы, которые не могут быть закодированы в локальной кодировке, возвращаемый массив байтов не определён. Эти символы могут быть подавлены или заменены другим.

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

long QString::toLong(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::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

Возвращает строку, преобразованную в целое число с основанием 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().

NSString *QString::toNSString() const

Создаёт NSString из QString. NSString автоматически освобождается.

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

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

short QString::toShort(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::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().

std::u16string QString::toStdU16String() const

Возвращает объект std::u16string с данными, содержащимися в этом QString. Данные Юникода совпадают с данными, возвращаемыми методом utf16().

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

См. также utf16(), toStdWString(), и toStdU32String().

std::u32string QString::toStdU32String() const

Возвращает объект std::u32string с данными, содержащимися в этом QString. Данные Юникода совпадают с данными, возвращаемыми методом toUcs4().

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

См. также toUcs4(), toStdWString(), и toStdU16String().

std::wstring QString::toStdWString() const

Возвращает объект std::wstring с данными, содержащимися в этом QString. std::wstring закодирован в utf16 на платформах, где wchar_t имеет ширину 2 байта (например, Windows), и в ucs4 на платформах, где wchar_t имеет ширину 4 байта (большинство систем Unix).

Этот метод в основном полезен для передачи QString функции, которая принимает объект std::wstring.

См. также utf16(), toLatin1(), toUtf8(), toLocal8Bit(), toStdU16String(), и toStdU32String().

uint QString::toUInt(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned int в системе счисления base (по умолчанию 10, должно быть целым числом от 2 до 36 или 0). Возвращает 0, если преобразование невозможно.

Если ok не nullptr, ошибка сообщается путем установки *ok в значение false, а успех — путем установки *ok в значение true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для локализованного преобразования используйте QLocale::toUInt()

Пример:

QString str = "FF";
bool ok;

uint hex = str.toUInt(&ok, 16);     // hex == 255, ok == true
uint dec = str.toUInt(&ok, 10);     // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toInt(), и QLocale::toUInt().

ulong QString::toULong(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned long в системе счисления base (по умолчанию 10, должно быть целым числом от 2 до 36 или 0). Возвращает 0, если преобразование невозможно.

Если ok не nullptr, ошибка сообщается путем установки *ok в значение false, а успех — путем установки *ok в значение true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для локализованного преобразования используйте QLocale::toULongLong()

Пример:

QString str = "FF";
bool ok;

ulong hex = str.toULong(&ok, 16);   // hex == 255, ok == true
ulong dec = str.toULong(&ok, 10);   // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number() и QLocale::toUInt().

qulonglong QString::toULongLong(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned long long в системе счисления base (по умолчанию 10, должно быть целым числом от 2 до 36 или 0). Возвращает 0, если преобразование невозможно.

Если ok не nullptr, ошибка сообщается путем установки *ok в значение false, а успех — путем установки *ok в значение true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для локализованного преобразования используйте QLocale::toULongLong()

Пример:

QString str = "FF";
bool ok;

quint64 hex = str.toULongLong(&ok, 16);    // hex == 255, ok == true
quint64 dec = str.toULongLong(&ok, 10);    // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toLongLong(), и QLocale::toULongLong().

ushort QString::toUShort(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в unsigned short в системе счисления base (по умолчанию 10, должно быть целым числом от 2 до 36 или 0). Возвращает 0, если преобразование невозможно.

Если ok не nullptr, ошибка сообщается путем установки *ok в значение false, а успех — путем установки *ok в значение true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для локализованного преобразования используйте QLocale::toUShort()

Пример:

QString str = "FF";
bool ok;

ushort hex = str.toUShort(&ok, 16);     // hex == 255, ok == true
ushort dec = str.toUShort(&ok, 10);     // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toShort(), и QLocale::toUShort().

QVector<uint> QString::toUcs4() const

Возвращает представление строки в формате UCS-4/UTF-32 в виде QVector<uint>.

UCS-4 — это кодировка Юникода, поэтому она без потерь. Все символы из этой строки будут закодированы в UCS-4. Любая недопустимая последовательность кодовых единиц в этой строке заменяется замещающим символом Юникода (QChar::ReplacementCharacter, что соответствует значению U+FFFD).

Возвращаемый вектор не завершается символом \0.

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

См. также fromUtf8(), toUtf8(), toLatin1(), toLocal8Bit(), QTextCodec, 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(), и QTextCodec.

int QString::toWCharArray(wchar_t *array) const

Заполняет array данными, содержащимися в этом объекте QString. Массив закодирован в UTF-16 на платформах, где wchar_t имеет ширину 2 байта (например, Windows), и в UCS-4 на платформах, где wchar_t имеет ширину 4 байта (большинство систем Unix).

array должен быть выделен вызывающей стороной и содержать достаточно места для хранения всей строки (выделение массива той же длины, что и строка, всегда достаточно).

Эта функция возвращает фактическую длину строки в array.

Примечание: Эта функция не добавляет нулевой символ в массив.

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

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

Усекает строку на заданный индекс position.

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

Пример:

QString str = "Vladivostok";
str.truncate(4);
// str == "Vlad"

Если position отрицательный, он эквивалентен нулю.

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

const QChar *QString::unicode() const

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

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

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

const ushort *QString::utf16() const

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

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

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

[static] 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!=(QLatin1String other) const

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

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

bool QString::operator!=(const char *other) const

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator!=(const QByteArray &other) const

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов есть символы NUL ('\0'), они будут включены в преобразование.

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

См. также QT_NO_CAST_FROM_ASCII.

QString &QString::operator+=(QChar ch)

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

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

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

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

Пример:

QString x = "free";
QString y = "dom";
x += y;
// x == "freedom"

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

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

QString &QString::operator+=(const QStringRef &str)

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

Добавляет фрагмент строки, на который ссылается str, к этой строке.

QString &QString::operator+=(QLatin1String str)

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

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

QString &QString::operator+=(const char *str)

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

QString &QString::operator+=(char ch)

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator<(QLatin1String other) const

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

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

bool QString::operator<(const char *other) const

Возвращает true, если эта строка лексикографически меньше строки other. В противном случае возвращает false.

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator<(const QByteArray &other) const

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов есть символы NUL ('\0'), они будут включены в преобразование.

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator<=(QLatin1String other) const

Возвращает true, если эта строка лексикографически меньше или равна строке параметра other. В противном случае возвращает false.

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

bool QString::operator<=(const char *other) const

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator<=(const QByteArray &other) const

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов присутствуют нулевые символы ('\0'), они будут включены в преобразование.

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

См. также QT_NO_CAST_FROM_ASCII.

QString &QString::operator=(QChar ch)

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

Устанавливает строку, содержащую единственный символ ch.

QString &QString::operator=(QLatin1String str)

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

Присваивает латинскую-1 строку str этой строке.

QString &QString::operator=(const char *str)

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

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

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

См. также QT_NO_CAST_FROM_ASCII и QT_RESTRICTED_CAST_FROM_ASCII.

QString &QString::operator=(char ch)

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

Присваивает символ ch этой строке. Обратите внимание, что символ преобразуется в Unicode с помощью функции fromLatin1(), в отличие от других 8-битных функций, которые работают с данными UTF-8.

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator==(QLatin1String other) const

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

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

bool QString::operator==(const char *other) const

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Функция останавливает преобразование при первом найденном нулевом символе или в конце массива байтов.

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator>(QLatin1String other) const

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

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

bool QString::operator>(const char *other) const

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator>(const QByteArray &other) const

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов присутствуют нулевые символы ('\0'), они будут включены в преобразование.

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator>=(QLatin1String other) const

Возвращает true, если эта строка лексически больше или равна строке-параметру other. В противном случае возвращает false.

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

bool QString::operator>=(const char *other) const

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator>=(const QByteArray &other) const

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов присутствуют нулевые символы ('\0'), они будут включены в преобразование.

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

См. также QT_NO_CAST_FROM_ASCII.

QCharRef QString::operator[](int position)