Класс 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");

Несмотря на то, что размер size() равен 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]" << endl;
}

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

Для извлечения нескольких байтов одновременно используйте 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 << 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³¹ байтов) в размере. Точное значение зависит от архитектуры, так как оно зависит от накладных расходов, необходимых для управления блоком данных, но не превышает 32 байта. Блоки сырых данных также ограничены использованием типа int в текущей версии до 2 ГБ минус 1 байт.

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

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

Примечания по локали

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

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

Сравнение символов 8-битных символов

В QByteArray понятие заглавных и строчных букв, а также того, какой символ больше или меньше другого символа, зависит от локали. Это влияет на функции, которые поддерживают параметр «регистронезависимый» или которые сравнивают или приводят к верхнему или нижнему регистру своих аргументов. Регистронезависимые операции и сравнения будут точными, если обе строки содержат только символы ASCII. (Если $LC_CTYPE установлен, большинство систем Unix «делают то, что нужно».) К функциям, на которые это влияет, относятся contains(), indexOf(), lastIndexOf(), операторы <(), <=(), >(), >=(), isLower(), isUpper(), toLower() и toUpper().

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

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

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

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

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

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

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

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

typedef QByteArray::const_iterator

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

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

typedef QByteArray::const_reverse_iterator

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

Этот typedef был введён в Qt 5.6.

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

typedef QByteArray::iterator

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

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

typedef QByteArray::reverse_iterator

Этот typedef предоставляет итератор обратного итератора STL-стиля для QByteArray.

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

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

QByteArray::QByteArray(int size, char ch)

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

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

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

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

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

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

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

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

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

См. также 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 << "]" << 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 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 , если этот массив байтов равен null; в противном случае возвращает false.

Пример:

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

Qt различает массивы байтов null и пустые массивы байтов по историческим причинам. Для большинства приложений важно, содержит ли массив байтов какие-либо данные, и это можно определить с помощью 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 равно false и size() массива байтов больше, чем width, то возвращаемый массив байтов является копией этого массива байтов.

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

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

См. также 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. Данные Unicode преобразуются в 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. Данные Unicode преобразуются в 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-символы '\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 был создан из сырых данных, не включающих символ завершения строки, то 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, а успех — путём установки *ok в true.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Сравнение регистрозависимое.

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

QByteRef QByteArray::operator[](int i)

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

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

Пример:

QByteArray ba;
for (int i = 0; i < 10; ++i)
    ba[i] = 'A' + i;
// ba == "ABCDEFGHIJ"

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

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