Класс QByteArray

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

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

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

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

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

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

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

Макросы

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

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

Помимо QByteArray, Qt также предоставляет класс QString для хранения строковых данных. Для большинства целей QString — это тот класс, который вы хотите использовать. Он хранит 16-битные символы Юникода, что упрощает хранение символов, не являющихся ASCII/Latin-1, в вашем приложении. Кроме того, 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 (int 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() может быть быстрее, чем оператор[](), так как он никогда не приводит к выполнению глубокой копии.

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

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() и remove() первые два аргумента – это позиция, с которой начинается удаление, и количество байтов, которые необходимо удалить.

При добавлении данных к непустому массиву с помощью append() массив будет перевыделен, а новые данные будут скопированы в него. Вы можете избежать этого поведения, вызвав reserve(), который предварительно выделяет определённый объём памяти. Вы также можете вызвать capacity(), чтобы узнать, сколько памяти фактически выделила QByteArray. Данные, добавленные к пустому массиву, не копируются.

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

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

QByteArray ba("We must be <b>bold</b>, very <b>bold</b>");
int 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' для массива байтов, а QByteArray() сравнивается с QByteArray(""). Мы рекомендуем всегда использовать isEmpty() и избегать isNull().

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

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

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

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

Замечания по локализации

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

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

Сравнения символов 8-битного кодирования

В QByteArray понятие верхнего и нижнего регистра, а также того, какой символ больше или меньше другого, выполняется в локали Latin-1. Это влияет на функции, которые поддерживают вариант без учёта регистра или которые сравнивают или приводят свои аргументы к верхнему или нижнему регистру. Функции, которые это затрагивают, включают contains(), indexOf(), lastIndexOf(), operator<(), operator<=(), operator>(), operator>=(), isLower(), isUpper(), toLower() и toUpper().

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

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

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

перечисление QByteArray::Base64Optionфлаги QByteArray::Base64Options

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

QByteArray::fromBase64() игнорирует параметры KeepTrailingEquals и OmitTrailingEquals и не будет сообщать об ошибках в случае их отсутствия или избыточности.

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

Тип Base64Options является псевдонимом для QFlags<Base64Option>. Он хранит комбинацию значений Base64Option, полученную с помощью оператора OR.

тип QByteArray::const_iterator

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

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

тип QByteArray::const_reverse_iterator

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

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

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

тип QByteArray::iterator

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

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

тип QByteArray::reverse_iterator

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

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

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

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

QByteArray::QByteArray(QByteArray &&other)

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

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

QByteArray::QByteArray(const QByteArray &other)

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

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

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

QByteArray::QByteArray(int size, char ch)

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

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

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

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

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

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

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

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

QByteArray::QByteArray()

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

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

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

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

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

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

QByteArray &QByteArray::append(char ch)

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

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

QByteArray &QByteArray::append(int count, char ch)

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

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

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

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

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

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

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

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

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

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

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

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

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

Добавляет строку str в этот массив байтов. Данные Unicode преобразуются в символы с 8 битами с помощью QString::toUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_TO_ASCII при компиляции приложений. Затем вам нужно явно вызвать QString::toUtf8() (или QString::toLatin1() или QString::toLocal8Bit()), если вы хотите преобразовать данные в const char *.

char QByteArray::at(int i) const

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

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

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

char QByteArray::back() const

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

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

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

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

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

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

int QByteArray::capacity() const

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

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

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

QByteArray::const_iterator QByteArray::cbegin() const

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

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

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

QByteArray::const_iterator QByteArray::cend() const

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

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

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

void QByteArray::chop(int n)

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

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

Пример:

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

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

QByteArray QByteArray::chopped(int len) const

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

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

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

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

void QByteArray::clear()

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

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

int QByteArray::compare(const char *c, Qt::CaseSensitivity cs = ...) const

Возвращает целое число, меньшее, равное или большее нуля, в зависимости от того, предшествует ли этот QByteArray строке, указанной c, в лексикографическом порядке. Сравнение выполняется с учётом регистра, заданного параметром cs.

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

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

int QByteArray::compare(const QByteArray &a, Qt::CaseSensitivity cs = ...) const

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

Возвращает целое число, меньшее, равное или большее нуля, в зависимости от того, предшествует ли этот QByteArray объекту QByteArray a в лексикографическом порядке. Сравнение выполняется с учётом регистра, заданного параметром cs.

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

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

QByteArray::const_iterator QByteArray::constBegin() const

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

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

const char *QByteArray::constData() const

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

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

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

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

QByteArray::const_iterator QByteArray::constEnd() const

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

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

bool QByteArray::contains(const QByteArray &ba) const

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

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

bool QByteArray::contains(char ch) const

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

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

bool QByteArray::contains(const char *str) const

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

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

int QByteArray::count(const QByteArray &ba) const

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

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

int QByteArray::count(char ch) const

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

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

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

int QByteArray::count(const char *str) const

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

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

int QByteArray::count() const

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

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

QByteArray::const_reverse_iterator QByteArray::crbegin() const

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

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

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

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;
}

Указатель остаётся действительным до тех пор, пока массив байтов не перевыделяется или не уничтожается. Для чтения, 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().

bool QByteArray::endsWith(const QByteArray &ba) const

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

Пример:

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

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

bool QByteArray::endsWith(char ch) const

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

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

bool QByteArray::endsWith(const char *str) const

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

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

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

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

Пример:

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

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

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

[static] QByteArray QByteArray::fromBase64(const QByteArray &base64)

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

Например:

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

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

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

[static] QByteArray QByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options)

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

Возвращает закодированную копию массива base64, используя алфавит, определённый параметром options. Входные данные не проверяются на валидность; невалидные символы во входных данных пропускаются, что позволяет продолжить декодирование с последующими символами.

Например:

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.

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

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

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

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

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

[static] 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, int size)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

char QByteArray::front() const

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

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

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

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

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

QByteRef QByteArray::front()

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

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

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

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

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

int QByteArray::indexOf(const QByteArray &ba, int from = 0) const

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

Пример:

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

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

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

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

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

Пример:

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

int QByteArray::indexOf(const char *str, int from = 0) const

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

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

int QByteArray::indexOf(const QString &str, int from = 0) const

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

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

Данные Unicode преобразуются в символы с 8-битовой кодировкой с помощью QString::toUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_TO_ASCII при компиляции ваших приложений. В этом случае вам нужно явно вызвать QString::toUtf8() (или QString::toLatin1() или QString::toLocal8Bit()), если вы хотите преобразовать данные в const char *.

QByteArray &QByteArray::insert(int i, const QByteArray &ba)

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

Пример:

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

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

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

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

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

QByteArray &QByteArray::insert(int i, int count, char ch)

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

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

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

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

QByteArray &QByteArray::insert(int i, const char *str)

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

Вставляет строку str в позицию i в массиве байтов.

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

QByteArray &QByteArray::insert(int i, const char *str, int len)

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

Вставляет len байтов строки str в позицию i в массиве байтов.

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

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

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

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

Вставляет строку str в позицию с индексом i в массиве байтов. Данные Unicode преобразуются в символы с 8-битовой кодировкой с помощью QString::toUtf8().

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

Вы можете отключить эту функцию, определив QT_NO_CAST_TO_ASCII при компиляции ваших приложений. В этом случае вам нужно явно вызвать QString::toUtf8() (или QString::toLatin1() или QString::toLocal8Bit()), если вы хотите преобразовать данные в const char *.

bool QByteArray::isEmpty() const

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

Пример:

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

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

bool QByteArray::isLower() const

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

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

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

bool QByteArray::isNull() const

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

Пример:

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

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

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

bool QByteArray::isUpper() const

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

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

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

int QByteArray::lastIndexOf(const QByteArray &ba, int from = -1) const

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

Пример:

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

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

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

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

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

Пример:

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

int QByteArray::lastIndexOf(const char *str, int from = -1) const

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

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

int QByteArray::lastIndexOf(const QString &str, int from = -1) const

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

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

Данные Unicode преобразуются в символы с 8-битовой кодировкой с помощью QString::toUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_TO_ASCII при компиляции ваших приложений. В этом случае вам нужно явно вызвать QString::toUtf8() (или QString::toLatin1() или QString::toLocal8Bit()), если вы хотите преобразовать данные в const char *.

QByteArray QByteArray::left(int len) const

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

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

Пример:

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

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

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

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

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

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

Пример:

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

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

int QByteArray::length() const

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

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

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

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

Пример:

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

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

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

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

Пример:

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

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

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

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

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

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

[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-формат независимо от локали пользователя.

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

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

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

Пример:

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

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

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

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

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

QByteArray &QByteArray::prepend(char ch)

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

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

QByteArray &QByteArray::prepend(int count, char ch)

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

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

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

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

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

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

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

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

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

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

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

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

QByteArray::reverse_iterator QByteArray::rbegin()

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

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

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

QByteArray::const_reverse_iterator QByteArray::rbegin() const

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

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

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

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

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

Пример:

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

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

QByteArray::reverse_iterator QByteArray::rend()

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

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

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

QByteArray::const_reverse_iterator QByteArray::rend() const

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

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

QByteArray QByteArray::repeated(int times) const

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

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

Пример:

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

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

QByteArray &QByteArray::replace(int pos, int len, const QByteArray &after)

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

Пример:

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

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

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

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

Заменяет len байтов с позиции индекса pos на строку after, завершённую символом '\0'.

Примечание: это может изменить длину массива байтов.

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

Это перегруженный функцией.

Заменяет len байтов с позиции индекса pos на alen байтов из строки after. В строке after разрешены символы '\0'.

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

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

Это перегруженный функцией.

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

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

Это перегруженный функцией.

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

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

Это перегруженный функцией.

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

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

Это перегруженный функцией.

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

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

Это перегруженный функцией.

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

Пример:

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

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

Это перегруженный функцией.

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

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

Это перегруженный функцией.

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

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

Это перегруженный функцией.

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

QByteArray &QByteArray::replace(const QString &before, const char *after)

Это перегруженный функцией.

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

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

Это перегруженный функцией.

Заменяет каждое вхождение символа before на строку after. Данные Юникода преобразуются в символы 8-битной кодировки с помощью QString::toUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_TO_ASCII при компиляции ваших приложений. Затем вам нужно явно вызвать QString::toUtf8() (или QString::toLatin1() или QString::toLocal8Bit()), если вы хотите преобразовать данные в const char *.

QByteArray &QByteArray::replace(const QString &before, const QByteArray &after)

Это перегруженный функцией.

Заменяет каждое вхождение строки before на массив байтов after. Данные Юникода преобразуются в символы 8-битной кодировки с помощью QString::toUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_TO_ASCII при компиляции ваших приложений. Затем вам нужно явно вызвать QString::toUtf8() (или QString::toLatin1() или QString::toLocal8Bit()), если вы хотите преобразовать данные в const char *.

void QByteArray::reserve(int size)

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

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

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

void QByteArray::resize(int size)

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

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

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

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

QByteArray QByteArray::right(int len) const

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

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

Пример:

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

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

QByteArray QByteArray::rightJustified(int 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) и возвращает ссылку на массив байтов. Значение base может быть любым значением от 2 до 36. Для систем счисления, отличных от 10, n обрабатывается как целое без знака.

Пример:

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

Примечание: Формат числа не локализован; используется локаль по умолчанию C независимо от локали пользователя.

См. также 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(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-локаль, независимо от локали пользователя.

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

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

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

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

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

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

Примечание: Формат числа не локализован; используется по умолчанию C-локаль, независимо от локали пользователя.

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

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

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

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

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

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

void QByteArray::shrink_to_fit()

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

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

QByteArray QByteArray::simplified() const

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

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

Пример:

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

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

int QByteArray::size() const

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

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

Пример:

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

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

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

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

void QByteArray::squeeze()

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

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

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

bool QByteArray::startsWith(const QByteArray &ba) const

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

Пример:

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

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

bool QByteArray::startsWith(char ch) const

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

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

bool QByteArray::startsWith(const char *str) const

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

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

void QByteArray::swap(QByteArray &other)

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

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

QByteArray QByteArray::toBase64() const

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

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

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

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

QByteArray QByteArray::toBase64(QByteArray::Base64Options options) const

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

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

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

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, а успех — в 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-локали, независимо от локали пользователя.

Этот метод игнорирует ведущие и завершающие пробелы.

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

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

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

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

Если ok не nullptr, неудача сообщается установкой *ok в false, а успех — в 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-локали, независимо от локали пользователя.

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

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

QByteArray QByteArray::toHex() const

Возвращает шестнадцатеричную кодированную копию массива байтов. Шестнадцатеричная кодировка использует числа от 0 до 9 и буквы от a до f.

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

QByteArray QByteArray::toHex(char separator) 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, которое по умолчанию равно 10 и должно быть в диапазоне от 2 до 36 или 0.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QByteArray QByteArray::toLower() const

Возвращает копию массива байтов в нижнем регистре. Массив байтов интерпретируется как строка в кодировке Latin-1.

Пример:

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

См. также isLower(), toUpper() и 8-битные сравнения символов.

NSData *QByteArray::toNSData() const

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

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

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

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

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

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

ALPHA ("a" до "z" и "A" до "Z") / DIGIT (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.

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

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

CFDataRef QByteArray::toRawCFData() const

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

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

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

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

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

NSData *QByteArray::toRawNSData() const

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

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

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

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

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

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

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

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

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

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

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

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

std::string QByteArray::toStdString() const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Данная функция была добавлена в Qt 4.1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QByteArray QByteArray::toUpper() const

Возвращает копию массива байтов в верхнем регистре. Массив байтов интерпретируется как строка в кодировке Latin-1.

Пример:

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

См. также isUpper(), toLower() и 8-битные сравнения символов.

QByteArray QByteArray::trimmed() const

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

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

Пример:

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

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

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

void QByteArray::truncate(int pos)

Обрезает массив байтов на индексе pos.

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

Пример:

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

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

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

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

Данные Unicode преобразуются в 8-битные символы с помощью QString::toUtf8().

Сравнение выполняется без учета регистра.

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

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

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

Добавляет строку str в конец этого массива байтов и возвращает ссылку на этот массив байтов. Данные Unicode преобразуются в 8-битные символы с помощью QString::toUtf8().

Вы можете отключить эту функцию, определив QT_NO_CAST_TO_ASCII при компиляции приложения. В таком случае необходимо явно вызвать QString::toUtf8() (или QString::toLatin1() или QString::toLocal8Bit()) для преобразования данных в const char *.

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

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

Данные Unicode преобразуются в 8-битные символы с помощью QString::toUtf8().

Сравнение выполняется без учета регистра.

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

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

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

Данные Unicode преобразуются в 8-битные символы с помощью QString::toUtf8().

Сравнение выполняется без учета регистра.

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

Данные Unicode преобразуются в 8-битные символы с помощью QString::toUtf8().

Сравнение выполняется без учета регистра.

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

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

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

Данные Unicode преобразуются в 8-битные символы с помощью QString::toUtf8().

Сравнение выполняется без учета регистра.

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

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

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

Данные Юникода преобразуются в символы 8-битной кодировки с помощью QString::toUtf8().

Сравнение учитывает регистр.

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

QByteRef QByteArray::operator[](int i)

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

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

Пример:

QByteArray ba("Hello, world");
cout << ba[0]; // prints H
ba[7] = 'W';
// ba == "Hello, World"

Значение возврата имеет тип QByteRef, вспомогательный класс для QByteArray. При получении объекта типа QByteRef, вы можете использовать его как char &. Если вы присваиваете значение, присваивание будет применено к символу в QByteArray, из которого вы получили ссылку.

Примечание: До Qt 5.14 было возможно использовать этот оператор для доступа к символу за пределами допустимого диапазона массива байтов, а затем присваивать значения в такие позиции, что приводило к автоматическому изменению размера массива байтов. Кроме того, присваивание значения возвращаемой QByteRef вызывало отсоединение массива байтов, даже если массив байтов был скопирован в это время (и QByteRef оставался активным во время копирования). Это поведение устарело и будет изменено в будущей версии Qt.

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

char QByteArray::operator[](int i) const

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

То же, что и at(i).

char QByteArray::operator[](uint i) const

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

QByteRef QByteArray::operator[](uint i)

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

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