Класс QString

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

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

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

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

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

Static Public Members

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

Макросы

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

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

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

Изменение данных строки

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

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

Если вы постепенно строите 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().

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

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

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

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

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

Несколько менее эффективный способ — использовать QLatin1String. Этот класс оборачивает строковый литерал C, предварительно вычисляет его длину на этапе компиляции, а затем может использоваться для более быстрого сравнения со строками QString и преобразования в QString, чем обычный строковый литерал 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^31 байт) размером. Точное значение зависит от архитектуры, так как оно зависит от накладных расходов, необходимых для управления блоком данных, но не более 32 байт. Необработанные блоки данных также ограничены использованием типа int в текущей версии до 2 ГБ минус 1 байт. Поскольку QString использует два байта на символ, это переводится примерно в чуть меньше 2^30 символов в одном 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 №15.

enum QString::SectionFlagflags QString::SectionFlags

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

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

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

enum QString::SplitBehavior

Этот перечисление определяет поведение функции split() в отношении пустых строк.

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

typedef QString::const_iterator

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

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

typedef QString::const_pointer

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

typedef QString::const_reference

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

typedef QString::const_reverse_iterator

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

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

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

typedef QString::difference_type

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

typedef QString::iterator

Псевдоним QString::iterator предоставляет итератор в стиле STL для QString без ограничений на изменение.

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

typedef QString::pointer

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

typedef QString::reference

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

typedef QString::reverse_iterator

Этот псевдоним предоставляет обратный итератор в стиле 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. Данная байтовая последовательность преобразуется в Юникод с помощью fromUtf8(). Преобразование прекращается при встрече первого нулевого символа, в противном случае копируется вся байтовая последовательность.

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

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

QString::QString(const char *str)

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

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

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

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

QString::QString(QString &&other)

Конструирует QString в режиме перемещения, позволяя ему указывать на тот же объект, что и other.

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

QString::QString(const QString &other)

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

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

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

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

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

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

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

Присваивает ba этой строке. Байтовая последовательность преобразуется в Юникод с помощью 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 в строку. Система счисления должна быть в диапазоне от 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, сравнение выполняется с учётом регистра; в противном случае — без учёта регистра.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

bool QString::contains(QRegExp &rx) const

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

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

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

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

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

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

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

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

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

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

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

Если совпадение найдено и 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 в строке.

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

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

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

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

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

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

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

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

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 символами латинской-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. Предполагается, что заданная строка закодирована в utf16, если размер wchar_t равен 2 байтам (например, в Windows), и в ucs4, если размер 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 (Byte Order Mark). Если его нет, предполагается порядок байтов хоста.

Этот метод медленнее по сравнению с другими преобразованиями Юникода. Если возможно, используйте 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 (Byte Order Mark). Если его нет, предполагается порядок байтов хоста.

Этот метод медленнее по сравнению с другими преобразованиями Юникода. Если возможно, используйте 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, если wchar имеет 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(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(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

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

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

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(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(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, если строка содержит только строчные буквы, в противном случае возвращает false.

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

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

bool QString::isNull() const

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

Пример:

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

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

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

bool QString::isRightToLeft() const

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

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

bool QString::isUpper() const

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

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

См. также QChar::isUpper() и 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(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 и size() строки больше, чем width, то возвращаемая строка является копией строки.

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

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

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

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

QStringRef QString::leftRef(int n) const

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

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

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

Если доступно меньше чем n символов в строке, начиная с заданного position, или если 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

Добавляет латинскую строку 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

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

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

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

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

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

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

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

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

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

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

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() с соответствующей локалью.

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

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

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

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

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

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

Возвращает строку, преобразованную в значение double.

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

Если ok не равен nullptr, ошибка отображается установкой *ok в false, а успех — в true.

QString str = "1234.56";
double val = str.toDouble();   // val == 1234.56

Предупреждение: Содержимое QString может содержать только допустимые числовые символы, включая знак плюс/минус, символ e в научной записи и десятичную точку. Включение единиц или дополнительных символов приводит к ошибке преобразования.

bool ok;
double d;

d = QString( "1234.56e-02" ).toDouble(&ok); // ok == true, d == 12.3456

d = QString( "1234.56e-02 Volt" ).toDouble(&ok); // ok == false, d == 0

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toDouble()

d = QString( "1234,56" ).toDouble(&ok); // ok == false
d = QString( "1234.56" ).toDouble(&ok); // ok == true, d == 1234.56

По историческим причинам эта функция не обрабатывает разделители тысяч. Если вам нужно преобразовывать такие числа, используйте QLocale::toDouble().

d = QString( "1,234,567.89" ).toDouble(&ok); // ok == false
d = QString( "1234567.89" ).toDouble(&ok); // ok == true

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), QLocale::setDefault(), QLocale::toDouble(), и trimmed().

float QString::toFloat(bool *ok = nullptr) const

Возвращает строку, преобразованную в значение float.

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

Если ok не равен nullptr, ошибка отображается установкой *ok в false, а успех — в true.

Предупреждение: Содержимое QString может содержать только допустимые числовые символы, включая знак плюс/минус, символ e в научной записи и десятичную точку. Включение единиц или дополнительных символов приводит к ошибке преобразования.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toFloat()

По историческим причинам эта функция не обрабатывает разделители тысяч. Если вам нужно преобразовывать такие числа, используйте QLocale::toFloat().

Пример:

QString str1 = "1234.56";
str1.toFloat();             // returns 1234.56

bool ok;
QString str2 = "R2D2";
str2.toFloat(&ok);          // returns 0.0, sets ok to false

QString str3 = "1234.56 Volt";
str3.toFloat(&ok);          // returns 0.0, sets ok to false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toDouble(), toInt(), QLocale::toFloat(), и trimmed().

QString QString::toHtmlEscaped() const

Преобразует строку простого текста в HTML-строку с заменой HTML-спецсимволов <, >, &, и " на HTML-сущности.

Пример:

QString plain = "#include <QtCore>"
QString html = plain.toHtmlEscaped();
// html == "#include &lt;QtCore&gt;"

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

int QString::toInt(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в целое число int с использованием основания base, по умолчанию 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование завершается неудачей.

Если ok не равен nullptr, ошибка отображается установкой *ok в false, а успех — в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если с "0", основание 8; в противном случае основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toInt()

Пример:

QString str = "FF";
bool ok;
int hex = str.toInt(&ok, 16);       // hex == 255, ok == true
int dec = str.toInt(&ok, 10);       // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toUInt(), toDouble(), и QLocale::toInt().

QByteArray QString::toLatin1() const

Возвращает представление строки в Latin-1 в виде QByteArray.

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

См. также fromLatin1(), toUtf8(), toLocal8Bit(), и 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

Возвращает строку, преобразованную в long с использованием основания base, по умолчанию 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование завершается неудачей.

Если ok не равен nullptr, ошибка отображается установкой *ok в false, а успех — в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если с "0", основание 8; в противном случае основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toLongLong()

Пример:

QString str = "FF";
bool ok;

long hex = str.toLong(&ok, 16);     // hex == 255, ok == true
long dec = str.toLong(&ok, 10);     // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toULong(), toInt(), и QLocale::toInt().

qlonglong QString::toLongLong(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в long long с использованием основания base, по умолчанию 10 и должно быть в диапазоне от 2 до 36 или 0. Возвращает 0, если преобразование завершается неудачей.

Если ok не равен nullptr, ошибка отображается установкой *ok в false, а успех — в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если с "0", основание 8; в противном случае основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toLongLong()

Пример:

QString str = "FF";
bool ok;

qint64 hex = str.toLongLong(&ok, 16);      // hex == 255, ok == true
qint64 dec = str.toLongLong(&ok, 10);      // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toULongLong(), toInt(), и QLocale::toLongLong().

QString QString::toLower() const

Возвращает копию строки в нижнем регистре.

QString str = "The Qt PROJECT";
str = str.toLower();        // str == "the qt project"

Преобразование регистра всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toLower()

См. также toUpper() и QLocale::toLower().

NSString *QString::toNSString() const

Создаёт NSString из QString. NSString будет автоматически освобождён.

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

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

short QString::toShort(bool *ok = nullptr, int base = 10) const

Возвращает строку, преобразованную в short с основанием base, по умолчанию 10 и должно быть между 2 и 36, или 0. Возвращает 0, если преобразование не удалось.

Если ok не nullptr, неудача сообщается, установив *ok в false, а успех — установив *ok в true.

Если base равно 0, используется соглашение языка C: если строка начинается с "0x", используется основание 16; если строка начинается с "0", используется основание 8; в противном случае используется основание 10.

Преобразование строки всегда происходит в локали 'C'. Для преобразования, зависящего от локали, используйте QLocale::toShort()

Пример:

QString str = "FF";
bool ok;

short hex = str.toShort(&ok, 16);   // hex == 255, ok == true
short dec = str.toShort(&ok, 10);   // dec == 0, ok == false

Эта функция игнорирует начальные и конечные пробелы.

См. также number(), toUShort(), toInt(), и QLocale::toShort().

std::string QString::toStdString() const

Возвращает объект std::string с данными, содержащимися в этом QString. Данные Unicode преобразуются в 8-битные символы с помощью функции toUtf8().

Этот метод в основном полезен для передачи QString в функцию, принимающую объект std::string.

См. также toLatin1(), toUtf8(), toLocal8Bit(), и QByteArray::toStdString().

std::u16string QString::toStdU16String() const

Возвращает объект std::u16string с данными, содержащимися в этом QString. Данные Unicode совпадают с данными, возвращаемыми методом utf16().

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

См. также utf16(), toStdWString(), и toStdU32String().

std::u32string QString::toStdU32String() const

Возвращает объект std::u32string с данными, содержащимися в этом QString. Данные Unicode совпадают с данными, возвращаемыми методом 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 — это кодировка Unicode, поэтому она без потерь. Все символы из этой строки будут закодированы в UCS-4. Любая недопустимая последовательность кодовых единиц в этой строке заменяется замещающим символом Unicode (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 — это кодировка Unicode и может представлять все символы в строке Unicode, такой как 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 должен быть выделен вызывающей стороной и содержать достаточно места для размещения всей строки (выделение массива с той же длиной, что и у строки, всегда достаточно).

Эта функция возвращает фактическую длину строки в массиве.

Примечание: Эта функция не добавляет нулевой символ в массив.

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

См. также utf16(), toUcs4(), toLatin1(), toUtf8(), toLocal8Bit() и toStdWString().

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

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

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

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

const ushort *QString::utf16() const

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

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

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator!=(const QByteArray &other) const

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

Массив байтов 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)

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

Добавляет фрагмент строки, на который ссылается str, в эту строку.

QString &QString::operator+=(QLatin1String str)

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

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

QString &QString::operator+=(const char *str)

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

QString &QString::operator+=(char ch)

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

Добавляет символ 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.

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator<(const QByteArray &other) const

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

Массив байтов 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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator<=(const QByteArray &other) const

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Если в массиве байтов встроены символы NULL ('\0'), они будут включены в преобразование.

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

См. также QT_NO_CAST_FROM_ASCII.

QString &QString::operator=(QChar ch)

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

Устанавливает строку, содержащую единственный символ ch.

QString &QString::operator=(QLatin1String str)

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

Присваивает латинскую-1 строку str этой строке.

QString &QString::operator=(const char *str)

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

Присваивает 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)

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

Присваивает символ 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

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

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

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

См. также QT_NO_CAST_FROM_ASCII.

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

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

Массив байтов other преобразуется в QString с помощью функции fromUtf8(). Функция останавливает преобразование при первом встреченном символе NULL или достижении конца массива байтов.

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

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

См. также QT_NO_CAST_FROM_ASCII.

bool QString::operator>(QLatin1String other) const

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