Класс QByteArray

Класс QByteArray предоставляет массив байтов. Подробнее...

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

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

Открытые типы

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

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

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

Макросы

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

QByteArray может использоваться для хранения как сырых байтов (включая '\0'), так и традиционных 8-битных строк с завершением '\0'. Использование QByteArray намного удобнее, чем использование const char *. Внутри она всегда гарантирует, что данные следуют за '\0' терминирователем, и использует неявное совместное использование (copy-on-write), чтобы уменьшить использование памяти и избежать ненужного копирования данных.

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

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

QByteArray ba("Hello");

Хотя размер() равен 5, массив байтов также сохраняет дополнительный байт '\0' в конце, так что, если используется функция, которая запрашивает указатель на данные (например, вызов data()), данные, на которые указывает указатель, гарантированно будут завершены '\0'.

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

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

QByteArray ba;
ba.resize(5);
ba[0] = 0x3c;
ba[1] = 0xb8;
ba[2] = 0x64;
ba[3] = 0x18;
ba[4] = 0xca;

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

for (qsizetype i = 0; i < ba.size(); ++i) {
    if (ba.at(i) >= 'a' && ba.at(i) <= 'f')
        cout << "Found character in range [a-f]" << Qt::endl;
}

at() может быть быстрее, чем оператор[](), так как он никогда не вызывает создание глубокой копии.

Для извлечения нескольких байтов одновременно используйте first(), last() или sliced().

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

QByteArray ba1("ca\0r\0t");
ba1.size();                     // Returns 2.
ba1.constData();                // Returns "ca" with terminating \0.

QByteArray ba2("ca\0r\0t", 3);
ba2.size();                     // Returns 3.
ba2.constData();                // Returns "ca\0" with terminating \0.

QByteArray ba3("ca\0r\0t", 4);
ba3.size();                     // Returns 4.
ba3.constData();                // Returns "ca\0r" with terminating \0.

const char cart[] = {'c', 'a', '\0', 'r', '\0', 't'};
QByteArray ba4(QByteArray::fromRawData(cart, 6));
ba4.size();                     // Returns 6.
ba4.constData();                // Returns "ca\0r\0t" without terminating \0.

Если вам нужно получить длину данных до первого байта '\0' включительно, вызовите qstrlen() для массива байтов.

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

Для получения указателя на фактические байты, вызовите data() или constData(). Эти функции возвращают указатель на начало данных. Указатель гарантированно остаётся валидным до тех пор, пока на QByteArray не вызывается функция, которая не является const. Также гарантируется, что данные заканчиваются байтом '\0', за исключением случаев, когда QByteArray была создана из сырых данных. Этот байт '\0' автоматически добавляется QByteArray и не учитывается в size().

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

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

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

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

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

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

Обратите внимание, что использование не-const операторов и функций может привести к созданию QByteArray глубокой копии данных из-за явного совместного использования.

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

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

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

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

QByteArray ba("We must be <b>bold</b>, very <b>bold</b>");
qsizetype j = 0;
while ((j = ba.indexOf("<b>", j)) != -1) {
    cout << "Found <b> tag at index position " << j << Qt::endl;
    ++j;
}

Если вам просто нужно проверить, содержит ли QByteArray определённую последовательность байтов, используйте contains(). Если вы хотите узнать, сколько раз встречается определённая последовательность байтов в массиве байтов, используйте count(). Если вы хотите заменить все вхождения определённого значения другим, используйте одну из перегрузок replace() с двумя параметрами.

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

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

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

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

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

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

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

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

Если выделение памяти завершается неудачей, QByteArray генерирует исключение std::bad_alloc если приложение компилируется с поддержкой исключений. Ситуации недостатка памяти в контейнерах Qt — единственные случаи, когда Qt генерирует исключения. Если исключения отключены, то недостаток памяти является неопределённым поведением.

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

Локаль C и функции ASCII

QByteArray, как правило, обрабатывает данные как байты без предположения каких-либо семантик; где она делает предположения о семантике, она использует локаль C и кодировку ASCII. Стандартные кодировки Unicode поддерживаются QString, другие кодировки могут поддерживаться с использованием QStringEncoder и QStringDecoder для преобразования в Unicode. Для локально-зависимой интерпретации текста используйте QLocale или QString.

Строки C

Традиционные строки C, также известные как строки с завершением '\0', представляют собой последовательности байтов, определяемые начальной точкой и неявно включающие каждый байт до, но не включая, первого байта '\0' после этого. Методы, которые принимают такой указатель без длины, интерпретируют его как эту последовательность байтов. По построению такая последовательность не может содержать байт '\0'.

Другие перегрузки принимают начальный указатель и количество байтов; они используют указанное количество байтов, следуя начальному адресу, независимо от того, являются ли некоторые из них байтами '\0'. В некоторых случаях, когда нет перегрузки, принимающей только указатель, передача длины -1 заставит метод использовать смещение первого байта '\0' после указателя в качестве длины; длина -1 должна передаваться только в том случае, если метод явно это говорит (в этом случае это обычно аргумент по умолчанию).

Символы пробелов

Часто требуется удалить символы пробелов из массива байтов ('\n', '\t', ' ', и т. д.). Если вы хотите удалить пробелы с обоих концов QByteArray, используйте trimmed(). Если вы также хотите заменить каждую группу символов пробелов одним символом пробела внутри массива байтов, используйте simplified(). Для этих целей распознаются только символы ASCII-пробелов.

Преобразования число-строка

Функции, которые выполняют преобразования между числовыми типами данных и строками, выполняются в локали C независимо от настроек локали пользователя. Используйте QLocale для выполнения локально-зависимых преобразований между числами и строками.

Регистр символов

В QByteArray понятие верхнего и нижнего регистра и регистронезависимого сравнения ограничено ASCII. Символы, отличные от ASCII, обрабатываются как регистронезависимые, поскольку их регистр зависит от кодировки. Это влияет на функции, которые поддерживают вариант регистронезависимого сравнения или изменяют регистр своих аргументов. К таким функциям относятся contains(), indexOf(), lastIndexOf(), isLower(), isUpper(), toLower() и toUpper().

Эта проблема не относится к QString, так как они представляют символы с использованием Unicode.

См. также QByteArrayView, QString и QBitArray.

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

[since 5.2] перечисление QByteArray::Base64Optionфлаги QByteArray::Base64Options

Это перечисление содержит доступные параметры для кодирования и декодирования Base64. Base64 определен в RFC 4648 со следующими параметрами:

QByteArray::fromBase64Encoding() и QByteArray::fromBase64() игнорируют параметры KeepTrailingEquals и OmitTrailingEquals. Если указан параметр IgnoreBase64DecodingErrors, они не будут отмечать ошибки в случае отсутствия конечных символов «равно» или если их слишком много. Если вместо этого указан AbortOnBase64DecodingErrors, вход должен либо не иметь заполнения, либо иметь правильное количество символов «равно».

Это перечисление было введено или изменено в Qt 5.2.

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

QByteArray::const_iterator

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

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

[since 5.6] QByteArray::const_reverse_iterator

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

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

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

QByteArray::iterator

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

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

[since 5.6] QByteArray::reverse_iterator

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

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

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

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

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

Декодирует массив Base64 base64, используя параметры, определённые в options. Если options содержит IgnoreBase64DecodingErrors (по умолчанию), вход не проверяется на корректность; недопустимые символы в вводе пропускаются, позволяя процессу декодирования продолжаться с последующими символами. Если options содержит AbortOnBase64DecodingErrors, декодирование прекратится на первом недопустимом символе.

Например:

void process(const QByteArray &);

if (auto result = QByteArray::fromBase64Encoding(encodedData))
    process(*result);

Алгоритм декодирования данных, закодированных в Base64, определён в RFC 4648.

Возвращает объект QByteArrayFromBase64Result, содержащий декодированные данные и флаг, указывающий, было ли декодирование успешным. Если был передан параметр AbortOnBase64DecodingErrors, и входные данные были некорректны, поведение декодированных данных не определено.

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

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

Примечание: В новом коде используйте constData() вместо этого.

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

Указатель остаётся действительным до тех пор, пока не произойдёт отсоединение, и QByteArray не будет изменён. Этот оператор в основном полезен для передачи массива байтов функции, принимающей const char *.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_BYTEARRAY при компиляции своих приложений.

Примечание: QByteArray может хранить любые значения байтов, включая '\0', но большинство функций, принимающих char * аргументы, предполагают, что данные заканчиваются на первой встреченной '\0'.

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

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

Создаёт экземпляр QByteArray, ссылаясь на тот же объект, на который ссылался other.

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

QByteArray::QByteArray(const QByteArray &other)

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

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

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

QByteArray::QByteArray(qsizetype size, char ch)

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

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

QByteArray::QByteArray(const char *data, qsizetype size = -1)

Создаёт массив байтов, содержащий первые size байтов массива data.

Если data равно 0, создаётся массив байтов со значением null.

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

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

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

QByteArray::QByteArray()

Создаёт пустой массив байтов.

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

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

Присваивает other этому экземпляру QByteArray.

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

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

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

QByteArray::~QByteArray()

Удаляет массив байтов.

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

Добавляет массив байтов ba в конец этого массива байтов.

Пример:

QByteArray x("free");
QByteArray y("dom");
x.append(y);
// x == "freedom"

Это то же самое, что insert(size(), ba).

Примечание: QByteArray — класс с неявным совместным использованием. Следовательно, если вы добавляете в пустой массив байтов, то массив байтов просто будет использовать данные, хранящиеся в ba. В этом случае копирование данных не выполняется, что занимает постоянное время. Если изменён экземпляр, совместно используемый с другими, он будет скопирован (copy-on-write), что занимает линейное время.

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

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

См. также operator+=(), prepend() и insert().

QByteArray &QByteArray::append(char ch)

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

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

[since 5.7] QByteArray &QByteArray::append(qsizetype count, char ch)

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

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

Если count отрицательное или равно нулю, ничего не добавляется в массив байтов.

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

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

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

Добавляет строку str с завершением '\0' в этот массив байтов.

QByteArray &QByteArray::append(const char *str, qsizetype len)

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

Добавляет первые len байтов, начиная с str, в этот массив байтов и возвращает ссылку на этот массив байтов. Добавляемые байты могут включать байты '\0'.

Если len отрицательное, str будет считаться строкой с завершением '\0', а длина для копирования будет определяться автоматически с помощью qstrlen().

Если len равно нулю или str равно null, ничего не добавляется в массив байтов. Убедитесь, что len не больше str.

QByteArray &QByteArray::append(QByteArrayView data)

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

Добавляет data в этот массив байтов.

char QByteArray::at(qsizetype i) const

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

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

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

[since 5.10] char QByteArray::back() const

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

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

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

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

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

[since 5.10] char &QByteArray::back()

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

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

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

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

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

QByteArray::iterator QByteArray::begin()

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

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

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

QByteArray::const_iterator QByteArray::begin() const

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

qsizetype QByteArray::capacity() const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void QByteArray::chop(qsizetype n)

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

Если n больше size(), результатом является пустой массив байтов.

Пример:

QByteArray ba("STARTTLS\r\n");
ba.chop(2);                 // ba == "STARTTLS"

См. также truncate(), resize() и first().

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

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

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

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

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

void QByteArray::clear()

Очищает содержимое массива байтов и делает его пустым.

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

[since 6.0] int QByteArray::compare(QByteArrayView bv, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

Возвращает целое число, меньшее, равное или большее нуля в зависимости от того, предшествует ли этот QByteArray QByteArrayView bv, расположен ли он в том же месте, или находится позже. Сравнение выполняется в соответствии с чувствительностью к регистру cs.

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

См. также operator== и Регистр символов.

QByteArray::const_iterator QByteArray::constBegin() const

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

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

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

const char *QByteArray::constData() const

Возвращает указатель на константные данные, хранящиеся в массиве байтов. Указатель может использоваться для доступа к байтам, составляющим массив. Данные завершаются '\0', если объект QByteArray не был создан из исходных данных.

Указатель остается действительным, пока не произойдет отделение и QByteArray не будет изменён.

Эта функция в основном полезна для передачи массива байтов функции, которая принимает const char *.

Примечание: QByteArray может хранить любые значения байтов, включая '\0', но большинство функций, принимающих аргументы char *, предполагают, что данные заканчиваются на первой встреченной '\0'.

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

QByteArray::const_iterator QByteArray::constEnd() const

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

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

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

[since 6.0] bool QByteArray::contains(QByteArrayView bv) const

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

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

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

bool QByteArray::contains(char ch) const

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

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

[since 6.0] qsizetype QByteArray::count(QByteArrayView bv) const

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

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

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

qsizetype QByteArray::count(char ch) const

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

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

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

qsizetype QByteArray::count() const

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

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

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

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

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

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

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

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

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

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

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

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

char *QByteArray::data()

Возвращает указатель на данные, хранящиеся в массиве байтов. Указатель можно использовать для доступа к байтам и их изменения, составляющим массив. Данные завершаются символом '\0', т.е. количество байтов, к которым вы можете получить доступ, следуя за возвращаемым указателем, равно size() + 1, включая терминатор '\0'.

Пример:

QByteArray ba("Hello world");
char *data = ba.data();
while (*data) {
    cout << "[" << *data << "]" << Qt::endl;
    ++data;
}

Указатель остается действительным, пока не произойдёт отсоединение и QByteArray не будет изменена.

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

Эта функция полезна главным образом для передачи массива байтов функции, которая принимает const char *.

Следующий пример делает копию char* возвращаемого data(), но он повредит кучу и приведёт к сбою, потому что не выделяет байт для '\0' в конце:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size()];
strcpy(data, text.data());
delete [] data;

Этот пример выделяет правильное количество места:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size() + 1];
strcpy(data, text.data());
delete [] data;

Примечание: QByteArray может хранить любые значения байтов, включая '\0', но большинство функций, которые принимают char * аргументы, предполагают, что данные заканчиваются на первом встретившемся '\0'.

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

const char *QByteArray::data() const

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

QByteArray::iterator QByteArray::end()

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

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

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

QByteArray::const_iterator QByteArray::end() const

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

[since 6.0] bool QByteArray::endsWith(QByteArrayView bv) const

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

Пример:

QByteArray url("http://qt-project.org/doc/qt-5.0/qtdoc/index.html");
if (url.endsWith(".html"))
    ...

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

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

bool QByteArray::endsWith(char ch) const

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

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

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

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

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

QByteArray &QByteArray::fill(char ch, qsizetype size = -1)

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

Пример:

QByteArray ba("Istambul");
ba.fill('o');
// ba == "oooooooo"

ba.fill('X', 2);
// ba == "XX"

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

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

Возвращает первые n байтов массива байтов.

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

Пример:

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

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

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

[static, since 5.2] QByteArray QByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding)

Возвращает декодированную копию массива Base64 base64, используя параметры, определённые в options. Если options содержит IgnoreBase64DecodingErrors (по умолчанию), вход не проверяется на корректность; недопустимые символы во вводе пропускаются, что позволяет процессу декодирования продолжить с последующими символами. Если options содержит AbortOnBase64DecodingErrors, декодирование прекратится на первом недопустимом символе.

Например:

QByteArray text = QByteArray::fromBase64("UXQgaXMgZ3JlYXQh");
text.data();            // returns "Qt is great!"

QByteArray::fromBase64("PHA+SGVsbG8/PC9wPg==", QByteArray::Base64Encoding); // returns "<p>Hello?</p>"
QByteArray::fromBase64("PHA-SGVsbG8_PC9wPg==", QByteArray::Base64UrlEncoding); // returns "<p>Hello?</p>"

Алгоритм декодирования Base64-закодированных данных определяется в RFC 4648.

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

Примечание: Функция fromBase64Encoding() рекомендуется в новом коде.

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

См. также toBase64() и fromBase64Encoding().

[static, since 5.3] QByteArray QByteArray::fromCFData(CFDataRef data)

Создаёт новый QByteArray, содержащий копию CFData data.

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

См. также fromRawCFData(), fromRawData(), toRawCFData() и toCFData().

[static] QByteArray QByteArray::fromHex(const QByteArray &hexEncoded)

Возвращает декодированную копию массива, закодированного в шестнадцатеричном формате hexEncoded. Вход не проверяется на корректность; недопустимые символы во вводе пропускаются, что позволяет процессу декодирования продолжить с последующими символами.

Например:

QByteArray text = QByteArray::fromHex("517420697320677265617421");
text.data();            // returns "Qt is great!"

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

[static, since 5.3] QByteArray QByteArray::fromNSData(const NSData *data)

Создаёт новый QByteArray, содержащий копию NSData data.

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

См. также fromRawNSData(), fromRawData(), toNSData() и toRawNSData().

[static] QByteArray QByteArray::fromPercentEncoding(const QByteArray &input, char percent = '%')

Возвращает декодированную копию кодированной в соответствии со стандартом URI/URL строки input. Параметр percent позволяет заменить символ '%' на другой (например, '_' или '=').

Например:

QByteArray text = QByteArray::fromPercentEncoding("Qt%20is%20great%33");
text.data();            // returns "Qt is great!"

Примечание: При некорректном вводе (например, строка, содержащая последовательность "%G5", которая не является допустимым шестнадцатеричным числом) результат также будет некорректным. Например, последовательность "%G5" может быть декодирована как 'W'.

См. также toPercentEncoding() и QUrl::fromPercentEncoding().

[static, since 5.3] QByteArray QByteArray::fromRawCFData(CFDataRef data)

Создаёт QByteArray, использующий байты из CFData data.

Байты из data не копируются.

Вызывающий код гарантирует, что CFData не будет удалён или изменён, пока существует этот объект QByteArray.

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

См. также fromCFData(), fromRawData(), toRawCFData() и toCFData().

[static] QByteArray QByteArray::fromRawData(const char *data, qsizetype size)

Создаёт QByteArray, использующий первые size байтов из массива data. Байты не копируются. QByteArray будет содержать указатель data. Вызывающий код гарантирует, что data не будет удалён или изменён, пока существует этот объект QByteArray и любые его копии, которые не были изменены. Другими словами, поскольку QByteArray — это класс с неявным совместным использованием, и экземпляр, возвращаемый этой функцией, содержит указатель data, вызывающий код не должен удалять data или изменять его напрямую, пока существует возвращаемый объект QByteArray и любые его копии. Однако QByteArray не принимает владение data, поэтому деструктор QByteArray никогда не удалит исходные данные data, даже когда последний QByteArray, ссылающийся на data, будет уничтожен.

Попытка модифицировать содержимое возвращаемого QByteArray или любой его копии приведёт к созданию глубокой копии массива data перед модификацией. Это гарантирует, что исходный массив data никогда не будет изменён объектом QByteArray.

Вот пример, как читать данные с помощью QDataStream на сырых данных в памяти, не копируя сырые данные в QByteArray:

 static const char mydata[] = {
    '\x00', '\x00', '\x03', '\x84', '\x78', '\x9c', '\x3b', '\x76',
    '\xec', '\x18', '\xc3', '\x31', '\x0a', '\xf1', '\xcc', '\x99',
    ...
    '\x6d', '\x5b'
};

QByteArray data = QByteArray::fromRawData(mydata, sizeof(mydata));
QDataStream in(&data, QIODevice::ReadOnly);
...

Предупреждение: Массив байтов, созданный с помощью fromRawData(), не является '\0'-завершённым, если исходные данные не содержат байт '\0' в позиции size. Хотя это не имеет значения для QDataStream или функций, таких как indexOf(), передача массива байтов в функцию, ожидающую const char * '\0'-завершённого массива, завершится ошибкой.

См. также setRawData(), data() и constData().

[static, since 5.3] QByteArray QByteArray::fromRawNSData(const NSData *data)

Создаёт QByteArray, использующий байты из NSData data.

Байты из data не копируются.

Вызывающий код гарантирует, что NSData не будет удалён или изменён, пока существует этот объект QByteArray.

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

См. также fromNSData(), fromRawData(), toRawNSData() и toNSData().

[static, since 5.4] QByteArray QByteArray::fromStdString(const std::string &str)

Возвращает копию строки str в виде QByteArray.

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

См. также toStdString() и QString::fromStdString().

[since 5.10] char QByteArray::front() const

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

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

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

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

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

[since 5.10] char &QByteArray::front()

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

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

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

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

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

[since 6.0] qsizetype QByteArray::indexOf(QByteArrayView bv, qsizetype from = 0) const

Возвращает индекс начала первого вхождения последовательности байтов, представленной объектом bv, в этом массиве байтов, начиная поиск с индекса from. Возвращает -1, если совпадение не найдено.

Пример:

QByteArray x("sticky question");
QByteArrayView 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

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

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

qsizetype QByteArray::indexOf(char ch, qsizetype from = 0) const

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

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

Пример:

QByteArray ba("ABCBA");
ba.indexOf("B");            // returns 1
ba.indexOf("B", 1);         // returns 1
ba.indexOf("B", 2);         // returns 3
ba.indexOf("X");            // returns -1

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

[since 6.0] QByteArray &QByteArray::insert(qsizetype i, QByteArrayView data)

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

Пример:

QByteArray ba("Meal");
ba.insert(1, QByteArrayView("ontr"));
// ba == "Montreal"

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

Массив увеличивается для размещения вставки. Если i выходит за пределы массива, массив сначала расширяется пробелами до достижения этого i.

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

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

QByteArray &QByteArray::insert(qsizetype i, const char *s)

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

Массив увеличивается для размещения вставки. Если i выходит за пределы массива, массив сначала расширяется пробелами до достижения этого i.

Функция эквивалентна insert(i, QByteArrayView(s))

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

QByteArray &QByteArray::insert(qsizetype i, const QByteArray &data)

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

Массив увеличивается для размещения вставки. Если i выходит за пределы массива, массив сначала расширяется пробелами до достижения этого i.

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

[since 5.7] QByteArray &QByteArray::insert(qsizetype i, qsizetype count, char ch)

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

Вставляет count копий байта ch в позицию с индексом i в массиве байтов.

Массив увеличивается для размещения вставки. Если i выходит за пределы массива, массив сначала расширяется пробелами до достижения этого i.

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

QByteArray &QByteArray::insert(qsizetype i, char ch)

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

Вставляет байт ch в позицию с индексом i в массиве байтов.

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

QByteArray &QByteArray::insert(qsizetype i, const char *data, qsizetype len)

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

Вставляет len байтов, начиная с data, в позицию i в массиве байтов.

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

bool QByteArray::isEmpty() const

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

Пример:

QByteArray().isEmpty();         // returns true
QByteArray("").isEmpty();       // returns true
QByteArray("abc").isEmpty();    // returns false

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

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

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

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

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

bool QByteArray::isNull() const

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

Пример:

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

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

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

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

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

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

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

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

Возвращает последние n байтов массива байтов.

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

Пример:

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

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

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

[since 6.0] qsizetype QByteArray::lastIndexOf(QByteArrayView bv, qsizetype from = -1) const

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

Пример:

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

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

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

qsizetype QByteArray::lastIndexOf(char ch, qsizetype from = -1) const

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

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

Пример:

QByteArray ba("ABCBA");
ba.lastIndexOf("B");        // returns 3
ba.lastIndexOf("B", 3);     // returns 3
ba.lastIndexOf("B", 2);     // returns 1
ba.lastIndexOf("X");        // returns -1

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

QByteArray QByteArray::left(qsizetype len) const

Возвращает массив байтов, содержащий первые len байтов этого массива байтов.

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

Возвращается весь массив байтов, если len больше, чем size().

Возвращает пустой QByteArray, если len меньше 0.

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

QByteArray QByteArray::leftJustified(qsizetype width, char fill = ' ', bool truncate = false) const

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

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

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

Пример:

QByteArray x("apple");
QByteArray y = x.leftJustified(8, '.');   // y == "apple..."

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

qsizetype QByteArray::length() const

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

QByteArray QByteArray::mid(qsizetype pos, qsizetype len = -1) const

Возвращает массив байтов, содержащий len байтов из этого массива байтов, начиная с позиции pos.

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

Если len равно -1 (по умолчанию), или pos + len >= size(), возвращает массив байтов, содержащий все байты, начиная с позиции pos до конца массива байтов.

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

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

Возвращает массив байтов, содержащий выведенное значение числа n в системе счисления с основанием base (по умолчанию 10). Поддерживаются основания от 2 до 36, используя буквы для цифр, превышающих 9: A — десять, B — одиннадцать и так далее.

Пример:

int n = 63;
QByteArray::number(n);              // returns "63"
QByteArray::number(n, 16);          // returns "3f"
QByteArray::number(n, 16).toUpper();  // returns "3F"

Примечание: Формат числа не локализован; используется по умолчанию C-локаль, независимо от локали пользователя. Используйте QLocale для выполнения локализованных преобразований между числами и строками.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[static] QByteArray QByteArray::number(double n, char f = 'g', int prec = 6)

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

Возвращает массив байтов, содержащий выведенное значение n, отформатированное по формату f с точностью prec.

Аргумент n форматируется в соответствии с указанным форматом f, который по умолчанию — g и может быть любым из следующих:

С 'e', 'E' и 'f', prec — количество цифр после десятичной точки. С 'g' и 'G', prec — максимальное количество значащих цифр (последующие нули опускаются).

QByteArray ba = QByteArray::number(12.3456, 'E', 3);
// ba == 1.235E+01

Примечание: Формат числа не локализован; используется локаль по умолчанию C независимо от локали пользователя. Используйте QLocale для выполнения локализованных преобразований между числами и строками.

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

QByteArray &QByteArray::prepend(QByteArrayView ba)

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

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

Пример:

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

Это то же самое, что и insert(0, ba).

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

QByteArray &QByteArray::prepend(char ch)

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

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

[since 5.7] QByteArray &QByteArray::prepend(qsizetype count, char ch)

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

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

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

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

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

Добавляет завершающуюся нулём строку str в начало этого массива байтов.

QByteArray &QByteArray::prepend(const char *str, qsizetype len)

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

Добавляет len байтов, начиная с str, в начало этого массива байтов. В добавленных байтах могут быть нулевые байты.

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

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

Добавляет ba в начало этого массива байтов.

void QByteArray::push_back(const QByteArray &other)

Этот метод предоставлен для совместимости со STL. Он эквивалентен append(other).

void QByteArray::push_back(char ch)

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

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

void QByteArray::push_back(const char *str)

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

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

[since 6.0] void QByteArray::push_back(QByteArrayView str)

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

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

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

void QByteArray::push_front(const QByteArray &other)

Этот метод предоставлен для совместимости со STL. Он эквивалентен prepend(other).

void QByteArray::push_front(char ch)

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

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

void QByteArray::push_front(const char *str)

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

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

[since 6.0] void QByteArray::push_front(QByteArrayView str)

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

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

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

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

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

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

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

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

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

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

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

QByteArray &QByteArray::remove(qsizetype pos, qsizetype len)

Удаляет len байтов из массива, начиная с индексной позиции pos, и возвращает ссылку на массив.

Если pos находится вне диапазона, ничего не происходит. Если pos допустимо, но pos + len больше размера массива, массив усекается до позиции pos.

Пример:

QByteArray ba("Montreal");
ba.remove(1, 4);
// ba == "Meal"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QByteArray QByteArray::repeated(qsizetype times) const

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

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

Пример:

QByteArray ba("ab");
ba.repeated(4);             // returns "abababab"

QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, QByteArrayView after)

Заменяет len байтов с индексной позиции pos на массив байтов after и возвращает ссылку на этот массив байтов.

Пример:

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

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

QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, const char *after, qsizetype alen)

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

Заменяет len байтов с индексной позиции pos на alen байтов, начиная с позиции after. Вставленные байты могут включать нулевые байты.

QByteArray &QByteArray::replace(char before, QByteArrayView after)

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

Заменяет каждое вхождение байта before на массив байтов after.

QByteArray &QByteArray::replace(const char *before, qsizetype bsize, const char *after, qsizetype asize)

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

Заменяет каждое вхождение bsize байтов, начиная с before, на asize байтов, начиная с after. Поскольку размеры строк заданы bsize и asize, они могут содержать байты '\0' и не обязательно должны быть завершены '\0'.

[since 6.0] QByteArray &QByteArray::replace(QByteArrayView before, QByteArrayView after)

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

Заменяет каждое вхождение байтового массива before на байтовый массив after.

Пример:

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

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

QByteArray &QByteArray::replace(char before, char after)

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

Заменяет каждое вхождение байта before на байт after.

void QByteArray::reserve(qsizetype size)

Попытка выделить память для не менее чем size байтов.

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

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

Предупреждение: reserve() резервирует память, но не изменяет размер байтового массива. Доступ к данным за пределами конца байтового массива является неопределённым поведением. Если необходимо получить доступ к памяти за пределами текущего конца массива, используйте resize().

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

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

void QByteArray::resize(qsizetype size)

Устанавливает размер байтового массива в size байтов.

Если size больше текущего размера, байтовый массив расширяется, чтобы он стал size байтов, а дополнительные байты добавляются в конец. Новые байты не инициализированы.

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

Примечание: Хотя resize() увеличит ёмкость при необходимости, он никогда не уменьшит ёмкость. Чтобы избавиться от избыточной ёмкости, используйте squeeze().

См. также size(), truncate() и squeeze().

QByteArray QByteArray::right(qsizetype len) const

Возвращает байтовый массив, содержащий последние len байтов этого байтового массива.

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

Весь байтовый массив возвращается, если len больше, чем size().

Возвращает пустой QByteArray, если len меньше 0.

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

QByteArray QByteArray::rightJustified(qsizetype width, char fill = ' ', bool truncate = false) const

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

Если truncate ложно и размер байтового массива больше width, то возвращаемый байтовый массив является копией этого байтового массива.

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

Пример:

QByteArray x("apple");
QByteArray y = x.rightJustified(8, '.');    // y == "...apple"

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

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

Устанавливает байтовый массив в выведенное значение n в системе счисления base (по умолчанию 10) и возвращает ссылку на байтовый массив. Поддерживаются системы счисления от 2 до 36, используя буквы для цифр больше 9; A — десять, B — одиннадцать и так далее. Для систем счисления, отличных от десятичной, n обрабатывается как целое без знака.

Пример:

QByteArray ba;
int n = 63;
ba.setNum(n);           // ba == "63"
ba.setNum(n, 16);       // ba == "3f"

Примечание: Формат числа не локализован; используется стандартный C-регион независимо от региона пользователя. Используйте QLocale для выполнения локализованных преобразований между числами и строками.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QByteArray &QByteArray::setNum(float n, char f = 'g', int prec = 6)

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

Устанавливает байтовый массив в выведенное значение n, отформатированное по формату f с точностью prec, и возвращает ссылку на байтовый массив.

Примечание: Формат числа не локализован; используется стандартный C-регион независимо от региона пользователя. Используйте QLocale для выполнения локализованных преобразований между числами и строками.

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

QByteArray &QByteArray::setNum(double n, char f = 'g', int prec = 6)

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

Устанавливает байтовый массив в выведенное значение n, отформатированное по формату f с точностью prec, и возвращает ссылку на байтовый массив.

Формат f может быть любым из следующих:

С 'e', 'E' и 'f', prec — количество цифр после десятичной точки. С 'g' и 'G', prec — максимальное количество значащих цифр (последующие нули опускаются).

Примечание: Формат числа не локализован; используется стандартный C-регион независимо от региона пользователя. Используйте QLocale для выполнения локализованных преобразований между числами и строками.

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

QByteArray &QByteArray::setRawData(const char *data, qsizetype size)

Сбрасывает QByteArray на использование первых size байтов массива data. Байты не копируются. QByteArray будет содержать указатель data. Вызывающий код гарантирует, что data не будет удалён или изменён до тех пор, пока существует этот QByteArray и любые его копии, которые не были изменены.

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

См. также fromRawData(), data() и constData().

[since 5.10] void QByteArray::shrink_to_fit()

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

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

QByteArray QByteArray::simplified() const

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

Символы пробелов — это те, для которых стандартная функция C++ isspace() возвращает true в C-локали; это ASCII-символы табуляции '\t', перевода строки '\n', возврата каретки '\r', вертикальной табуляции '\v', разделителя страницы '\f' и пробела ' '.

Пример:

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.simplified();
// ba == "lots of whitespace";

См. также trimmed(), QChar::SpecialCharacter и Символы пробелов.

qsizetype QByteArray::size() const

Возвращает количество байтов в этом массиве байтов.

Последний байт в массиве байтов находится в позиции size() - 1. Кроме того, QByteArray гарантирует, что байт в позиции size() всегда равен '\0', так что вы можете использовать возвращаемое значение data() и constData() в качестве аргументов функциям, которые ожидают строки, завершённые '\0'. Если объект QByteArray был создан из сырых данных, которые не включали завершающий байт '\0', то QByteArray не добавляет его автоматически, если не создаётся глубокая копия.

Пример:

QByteArray ba("Hello");
qsizetype n = ba.size();    // n == 5
ba.data()[0];               // returns 'H'
ba.data()[4];               // returns 'o'
ba.data()[5];               // returns '\0'

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

QList<QByteArray> QByteArray::split(char sep) const

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

void QByteArray::squeeze()

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

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

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

[since 6.0] bool QByteArray::startsWith(QByteArrayView bv) const

Возвращает true если этот массив байтов начинается с последовательности байтов, представленных bv; в противном случае возвращает false.

Пример:

QByteArray url("ftp://ftp.qt-project.org/");
if (url.startsWith("ftp:"))
    ...

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

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

bool QByteArray::startsWith(char ch) const

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

Возвращает true если этот массив байтов начинается с байта ch; в противном случае возвращает false.

void QByteArray::swap(QByteArray &other)

Меняет местами массив байтов other с этим массивом байтов. Эта операция очень быстрая и никогда не терпит неудачу.

[since 5.2] QByteArray QByteArray::toBase64(QByteArray::Base64Options options = Base64Encoding) const

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

QByteArray text("Qt is great!");
text.toBase64();        // returns "UXQgaXMgZ3JlYXQh"

QByteArray text("<p>Hello?</p>");
text.toBase64(QByteArray::Base64Encoding | QByteArray::OmitTrailingEquals);      // returns "PHA+SGVsbG8/PC9wPg"
text.toBase64(QByteArray::Base64Encoding);                                       // returns "PHA+SGVsbG8/PC9wPg=="
text.toBase64(QByteArray::Base64UrlEncoding);                                    // returns "PHA-SGVsbG8_PC9wPg=="
text.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);   // returns "PHA-SGVsbG8_PC9wPg"

Алгоритм, используемый для кодирования Base64-данных, определён в RFC 4648.

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

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

[since 5.3] CFDataRef QByteArray::toCFData() const

Создаёт CFData из QByteArray.

Вызывающий код владеет объектом CFData и отвечает за его освобождение.

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

См. также toRawCFData(), fromCFData(), fromRawCFData() и fromRawData().

double QByteArray::toDouble(bool *ok = nullptr) const

Возвращает массив байтов, преобразованный в значение double.

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

Если ok не nullptr, ошибка сообщается путём установки *ok в false, а успех путём установки *ok в true.

QByteArray string("1234.56");
bool ok;
double a = string.toDouble(&ok);   // a == 1234.56, ok == true

string = "1234.56 Volt";
a = str.toDouble(&ok);             // a == 0, ok == false

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

Примечание: Преобразование числа выполняется в стандартной C-локали независимо от локали пользователя. Используйте QLocale для выполнения преобразований между числами и строками с учётом локали.

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

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

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

Возвращает массив байтов, преобразованный в значение float.

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

Если ok не nullptr, ошибка сообщается путём установки *ok в false, а успех путём установки *ok в true.

QByteArray string("1234.56");
bool ok;
float a = string.toFloat(&ok);    // a == 1234.56, ok == true

string = "1234.56 Volt";
a = str.toFloat(&ok);              // a == 0, ok == false

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

Примечание: Преобразование числа выполняется в стандартной C-локали независимо от локали пользователя. Используйте QLocale для выполнения преобразований между числами и строками с учётом локали.

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

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

[since 5.9] QByteArray QByteArray::toHex(char separator = '\0') const

Возвращает шестнадцатеричную кодированную копию массива байтов.

Шестнадцатеричное кодирование использует числа от 0 до 9 и буквы от a до f.

Если separator не '\0', то разделитель вставляется между шестнадцатеричными байтами.

Пример:

QByteArray macAddress = QByteArray::fromHex("123456abcdef");
macAddress.toHex(':'); // returns "12:34:56:ab:cd:ef"
macAddress.toHex(0);   // returns "123456abcdef"

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

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

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

Возвращает массив байтов, преобразованный в целое число int с использованием основания base, которое по умолчанию равно десяти. Поддерживаются основания 0 и от 2 до 36, используя буквы для цифр, больших 9; A — десять, B — одиннадцать и так далее.

Если base равно 0, основание определяется автоматически по следующим правилам: если байтовый массив начинается с "0x", предполагается, что он шестнадцатеричный (основание 16); в противном случае, если он начинается с "0", предполагается, что он восьмеричный (основание 8); в противном случае предполагается десятичный.

Возвращает 0, если преобразование не удалось.

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

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

Примечание: Преобразование числа выполняется в стандартном C-локали, независимо от локали пользователя. Используйте QLocale, чтобы выполнить преобразование чисел и строк с учетом локали.

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

long QByteArray::toLong(bool *ok = nullptr, int base = 10) const

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

Если base равно 0, основание определяется автоматически по следующим правилам: если байтовый массив начинается с "0x", предполагается, что он шестнадцатеричный (основание 16); в противном случае, если он начинается с "0", предполагается, что он восьмеричный (основание 8); в противном случае предполагается десятичный.

Возвращает 0, если преобразование не удалось.

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

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

Примечание: Преобразование числа выполняется в стандартном C-локали, независимо от локали пользователя. Используйте QLocale, чтобы выполнить преобразование чисел и строк с учетом локали.

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

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

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

Если base равно 0, основание определяется автоматически по следующим правилам: если байтовый массив начинается с "0x", предполагается, что он шестнадцатеричный (основание 16); в противном случае, если он начинается с "0", предполагается, что он восьмеричный (основание 8); в противном случае предполагается десятичный.

Возвращает 0, если преобразование не удалось.

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

Примечание: Преобразование числа выполняется в стандартном C-локали, независимо от локали пользователя. Используйте QLocale, чтобы выполнить преобразование чисел и строк с учетом локали.

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

QByteArray QByteArray::toLower() const

Возвращает копию байтового массива, в которой все ASCII прописные буквы преобразованы в строчные.

Пример:

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toLower();
// y == "qt by the qt company"

См. также isLower(), toUpper() и Регистр символов.

[since 5.3] NSData *QByteArray::toNSData() const

Создаёт NSData из QByteArray.

Объект NSData автоматически освобождается.

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

См. также fromNSData(), fromRawNSData(), fromRawData() и toRawNSData().

QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray(), char percent = '%') const

Возвращает URI/URL-стиль кодировку процентов в виде копии этого байтового массива. Параметр percent позволяет заменить символ '%' по умолчанию на другой.

По умолчанию эта функция кодирует все байты, которые не являются одним из следующих:

ALPHA ("a" до "z" и "A" до "Z") / ЦИФРА (0 до 9) / "-" / "." / "_" / "~"

Для предотвращения кодирования байтов передайте их в exclude. Для принудительной кодировки байтов передайте их в include. Символ '%' всегда кодируется.

Пример:

QByteArray text = "{a fishy string?}";
QByteArray ba = text.toPercentEncoding("{}", "s");
qDebug(ba.constData());
// prints "{a fi%73hy %73tring%3F}"

Шестнадцатеричная кодировка использует цифры от 0 до 9 и прописные буквы от A до F.

См. также fromPercentEncoding() и QUrl::toPercentEncoding().

[since 5.3] CFDataRef QByteArray::toRawCFData() const

Создаёт CFData, использующий байты QByteArray.

Байты QByteArray не копируются.

Вызывающий гарантирует, что QByteArray не будет удалён или изменён, пока существует этот объект CFData.

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

См. также toCFData(), fromRawCFData(), fromCFData() и fromRawData().

[since 5.3] NSData *QByteArray::toRawNSData() const

Создаёт NSData, использующий байты QByteArray.

Байты QByteArray не копируются.

Вызывающий гарантирует, что QByteArray не будет удалён или изменён, пока существует этот объект NSData.

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

См. также fromRawNSData(), fromNSData(), fromRawData() и toNSData().

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

Возвращает байтовый массив, преобразованный в short с основанием base, по умолчанию равным 10. Поддерживаются основания 0 и от 2 до 36, используя буквы для цифр больше 9; A — десять, B — одиннадцать и так далее.

Если base равно 0, основание определяется автоматически по следующим правилам: если байтовый массив начинается с "0x", предполагается шестнадцатеричное; в противном случае, если он начинается с "0", предполагается восьмеричное; в противном случае предполагается десятичное.

Возвращает 0, если преобразование не удалось.

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

Примечание: Преобразование числа выполняется в стандартном C-локали, независимо от локали пользователя. Используйте QLocale, чтобы выполнить преобразование чисел и строк с учетом локали.

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

[since 5.4] std::string QByteArray::toStdString() const

Возвращает объект std::string с данными, содержащимися в этом QByteArray.

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

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

См. также fromStdString() и QString::toStdString().

uint QByteArray::toUInt(bool *ok = nullptr, int base = 10) const

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

Если base равно 0, основание определяется автоматически по следующим правилам: если байтовый массив начинается с "0x", предполагается шестнадцатеричное (основание 16); в противном случае, если он начинается с "0", предполагается восьмеричное (основание 8); в противном случае предполагается десятичное.

Возвращает 0, если преобразование не удалось.

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

Примечание: Преобразование числа выполняется в стандартном C-локали, независимо от локали пользователя. Используйте QLocale, чтобы выполнить преобразование чисел и строк с учетом локали.

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

ulong QByteArray::toULong(bool *ok = nullptr, int base = 10) const

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

Если base равно 0, основание определяется автоматически по следующим правилам: если байтовый массив начинается с "0x", предполагается шестнадцатеричное (основание 16); в противном случае, если он начинается с "0", предполагается восьмеричное (основание 8); в противном случае предполагается десятичное.

Возвращает 0, если преобразование не удалось.

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

Примечание: Преобразование числа выполняется в стандартном C-локали, независимо от локали пользователя. Используйте QLocale, чтобы выполнить преобразование чисел и строк с учетом локали.

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

qulonglong QByteArray::toULongLong(bool *ok = nullptr, int base = 10) const

Возвращает байтовый массив, преобразованный в unsigned long long с основанием base, по умолчанию равным 10. Поддерживаются основания 0 и от 2 до 36, используя буквы для цифр больше 9; A — десять, B — одиннадцать и так далее.

Если base равно 0, основа определяется автоматически по следующим правилам: Если массив байтов начинается с "0x", предполагается, что он шестнадцатеричный (основание 16); в противном случае, если он начинается с "0", предполагается, что он восьмеричный (основание 8); в противном случае предполагается десятичный.

Возвращает 0, если преобразование не выполнено.

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

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

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

ushort QByteArray::toUShort(bool *ok = nullptr, int base = 10) const

Возвращает массив байтов, преобразованный в unsigned short с основанием base, которое по умолчанию равно десяти. Поддерживаются основания 0 и от 2 до 36, используя буквы для цифр больше 9; A — десять, B — одиннадцать и так далее.

Если base равно 0, основа определяется автоматически по следующим правилам: Если массив байтов начинается с "0x", предполагается шестнадцатеричное значение; в противном случае, если он начинается с "0", предполагается восьмеричное значение; в противном случае предполагается десятичное.

Возвращает 0, если преобразование не выполнено.

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

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

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

QByteArray QByteArray::toUpper() const

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

Пример:

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toUpper();
// y == "QT BY THE QT COMPANY"

См. также isUpper(), toLower(), и Регистр символов.

QByteArray QByteArray::trimmed() const

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

Пробельные символы — это те, для которых стандартная C++ функция isspace() возвращает true в локали C; это ASCII-символы табуляции '\t', перевод строки '\n', возврат каретки '\r', вертикальная табуляция '\v', подача страницы '\f' и пробел ' '.

Пример:

QByteArray ba("  lots\t of\nwhitespace\r\n ");
ba = ba.trimmed();
// ba == "lots\t of\nwhitespace";

В отличие от simplified(), trimmed() оставляет внутренние пробелы неизменными.

См. также simplified(), QChar::SpecialCharacter и Пробельные символы.

void QByteArray::truncate(qsizetype pos)

Усекает массив байтов до индекса pos.

Если pos выходит за пределы массива, ничего не происходит.

Пример:

QByteArray ba("Stockholm");
ba.truncate(5);             // ba == "Stock"

См. также chop(), resize() и first().

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

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

Сравнение чувствительно к регистру.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложений. Затем вам необходимо явно вызвать QString::fromUtf8(), QString::fromLatin1() или QString::fromLocal8Bit(), если вы хотите преобразовать массив байтов в QString перед сравнением.

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

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

Пример:

QByteArray x("free");
QByteArray y("dom");
x += y;
// x == "freedom"

Примечание: QByteArray — это класс явного совместного использования. Следовательно, если вы добавляете данные к пустому массиву байтов, массив байтов просто будет совместно использовать данные, хранящиеся в ba. В этом случае копирование данных не выполняется, и время выполнения — постоянное (постоянное время). Если изменён общий экземпляр, он будет скопирован (копирование при записи), и время выполнения — линейное (линейное время).

Если добавляемый массив байтов не пустой, выполняется глубокая копия данных, и время выполнения — линейное (линейное время).

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

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

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

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

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

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

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

Добавляет строку str с завершением '\0' в конец этого массива байтов и возвращает ссылку на этот массив байтов.

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

Возвращает true, если этот массив байтов лексикографически меньше кодировки UTF-8 строки str; в противном случае возвращает false.

Сравнение чувствительно к регистру.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложений. Затем вам необходимо явно вызвать QString::fromUtf8(), QString::fromLatin1() или QString::fromLocal8Bit(), если вы хотите преобразовать массив байтов в QString перед сравнением.

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

Возвращает true, если этот массив байтов лексикографически меньше или равен кодировке UTF-8 строки str; в противном случае возвращает false.

Сравнение чувствительно к регистру.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложений. Затем вам необходимо явно вызвать QString::fromUtf8(), QString::fromLatin1() или QString::fromLocal8Bit(), если вы хотите преобразовать массив байтов в QString перед сравнением.

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

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

Присваивает str этому массиву байтов.

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

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

Сравнение чувствительно к регистру.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложений. Затем вам необходимо явно вызвать QString::fromUtf8(), QString::fromLatin1() или QString::fromLocal8Bit(), если вы хотите преобразовать массив байтов в QString перед сравнением.

bool QByteArray::operator>(const QString &str) const

Возвращает true, если этот массив байтов лексикографически больше кодировки UTF-8 строки str; в противном случае возвращает false.

Сравнение чувствительно к регистру.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложений. Затем вам необходимо явно вызвать QString::fromUtf8(), QString::fromLatin1() или QString::fromLocal8Bit(), если вы хотите преобразовать массив байтов в QString перед сравнением.

bool QByteArray::operator>=(const QString &str) const

Возвращает true, если этот массив байтов лексикографически больше или равен кодировке UTF-8 строки str; в противном случае возвращает false.

Сравнение чувствительно к регистру.

Вы можете отключить этот оператор, определив QT_NO_CAST_FROM_ASCII при компиляции приложений. Затем вам необходимо явно вызвать QString::fromUtf8(), QString::fromLatin1() или QString::fromLocal8Bit(), если вы хотите преобразовать массив байтов в QString перед сравнением.

char &QByteArray::operator[](qsizetype i)

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

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

Пример:

QByteArray ba("Hello, world");
cout << ba[0]; // prints H
ba[7] = 'W';
// ba == "Hello, World"

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

char QByteArray::operator[](qsizetype i) const

Это перегруженный функцией.

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

QByteArray ba = QByteArrayLiteral("byte array contents");