Класс QByteArray

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

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

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

Публичные типы

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

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

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

Макросы

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

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 для встроенных 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, используйте 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

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

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

[since 5.6] QByteArray::reverse_iterator

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

Возвращает указатель на данные, хранящиеся в массиве байтов. Указатель может быть использован для доступа к байтам, составляющим массив. Данные завершаются символом '\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 из функции очень быстрым. Если изменён общий экземпляр, он будет скопирован (копирование при записи), что займёт линейное время.

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

QByteArray::QByteArray(qsizetype size, char ch)

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

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

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

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

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

Если 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 с завершающим нулём в этот массив байтов.

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

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

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

Если len отрицательное, str будет считаться строкой с завершающим нулём, а длина для копирования будет определена автоматически с помощью 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, указывающий на первый байт в массиве байтов.

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

QByteArray::const_iterator QByteArray::begin() const

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

qsizetype QByteArray::capacity() const

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

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

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

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

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

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

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

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

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

Эта функция была введена в 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 байтов этого массива байтов.

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

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

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

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

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

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

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

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

См. также 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 байтов массива байтов.

Пример:

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 был передан и входные данные были неверными, пустой массив байтов.

Эта функция была добавлена в 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!"

См. также 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 никогда не будет удалять исходные данные, даже когда последний QByteArray, ссылающийся на data, будет уничтожен.

Попытка изменить содержимое возвращённого QByteArray или любой созданной из него копии приведёт к созданию глубокой копии массива 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);
...

См. также 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 байтов массива байтов.

Пример:

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) const

Возвращает позицию индекса начала последнего вхождения последовательности байтов, просматриваемой bv, в этом массиве байтов, ищущей назад с позиции индекса from. Если from равно -1, поиск начинается с последнего символа; если from равно -2, с предпоследнего символа и так далее. Возвращает -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().

[since 6.2] qsizetype QByteArray::lastIndexOf(QByteArrayView bv) const

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

Возвращает позицию индекса начала последнего вхождения последовательности байтов, просматриваемой bv, в этом массиве байтов, ищущей назад с конца массива байтов. Возвращает -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.2.

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

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 в виде текста.

Возвращает массив байтов, содержащий строку, представляющую 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"

См. также 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 format = 'g', int precision = 6)

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

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

Возвращает байтовую массив, содержащую строку, представляющую n, с заданным format и precision, имеющими те же значения, что и для QString::number(double, char, int). Например:

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

См. также toDouble() и QLocale::FloatingPointPrecisionOption.

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

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

Этот метод был введён в 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

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

Если раз меньше 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' и не обязаны завершаться байтом '\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 является недооценённым, массив будет увеличиваться по мере необходимости, как только зарезервированный размер будет превышен, что может привести к большему выделению памяти, чем ваша лучшая переоценка, и замедлить операцию, которая её вызывает.

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

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

void QByteArray::resize(qsizetype size)

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

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

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

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

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

Пример:

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

См. также 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 format = 'g', int precision = 6)

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

Представляет число с плавающей точкой n как текст.

Устанавливает этот массив байтов в строку, представляющую n, с заданным форматом format и точностью precision (с тем же значением, что и для QString::number(double, char, int)), и возвращает ссылку на этот массив байтов.

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

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

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

Представляет число с плавающей точкой n в виде текста.

Устанавливает этот массив байтов в строку, представляющую n, с заданным форматом и точностью (с теми же значениями, что и для QString::number(double, char, int)), и возвращает ссылку на этот массив байтов.

См. также toDouble() и QLocale::FloatingPointPrecisionOption.

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.

Пример:

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 в этом объекте и до конца этого объекта.

Этот метод был добавлен в 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

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

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

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

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

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

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

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

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

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

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

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

Возвращает массив байтов, преобразованный в целое число типа 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

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

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

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

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

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

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

См. также 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 с завершением '\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).

auto str = "hello"_qba;

QByteArray ba = QByteArrayLiteral("byte array contents");