Класс QByteArray

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

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

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

Типы public

Public Функции

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

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

Макросы

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

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

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

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

QByteArray ba("Hello");

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

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

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

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 не будет вызван не-константный метод. Также гарантируется, что данные завершаются байтом '\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 и заранее примерно знаете, сколько байтов она будет содержать, вы можете вызвать reserve(), попросив QByteArray предварительно выделить определённое количество памяти. Вы также можете вызвать capacity() для определения фактического количества выделенной памяти QByteArray.

Обратите внимание, что использование не-константных операторов и функций может привести к тому, что 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 различает массив байтов с нулевым значением и пустой массив байтов. Массив байтов с нулевым значением — это массив байтов, инициализированный с помощью конструктора по умолчанию QByteArray или путём передачи (const char *)0 в конструктор. Пустой массив байтов — это любой массив байтов с размером 0. Массив байтов с нулевым значением всегда пустой, но пустой массив байтов не обязательно нулевой:

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

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(), не является завершённым нулём, если исходные данные не содержат нулевой байт в позиции size. Хотя это не имеет значения для QDataStream или функций, таких как indexOf(), передача байтового массива функции, ожидающей const char * завершённого нулём, завершится ошибкой.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 — 10, B — 11 и так далее.

Пример:

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, в начало этого байтового массива. Добавляемые байты могут включать байты '\0'.

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 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. Вставляемые байты могут включать байты '\0'.

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' и не обязательно должны быть завершены нулём.

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

Если truncate равно true и размер массива байтов больше 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() в качестве аргументов для функций, которые ожидают нуль-терминированные строки. Если объект 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 типа long с основанием 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;
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, которое по умолчанию равно десяти. Поддерживаются основания 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 позволяет переопределить символ '%' по умолчанию.

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

БУКВЫ ("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, которое по умолчанию равно десяти. Поддерживаются основания 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, которое по умолчанию равно десяти. Поддерживаются основания 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, которое по умолчанию равно десяти. Поддерживаются основания 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, которое по умолчанию равно десяти. Поддерживаются основания 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. В этом случае копирование данных не выполняется, что занимает постоянное время. Если изменённая общая часть экземпляра, то будет создана копия (copy-on-write), занимающая линейное время.

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

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

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

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

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

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

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 перед выполнением сравнения.

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");