Класс 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() может быть быстрее, чем оператор[](), так как никогда не вызывает глубокое копирование 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 << Qt::endl;
    ++j;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В QByteArray понятие верхнего и нижнего регистра, а также сравнение символов «больше» или «меньше» выполняется в локали Latin-1. Это влияет на функции, которые поддерживают опцию без учёта регистра или сравнивают или приводят к нижнему или верхнему регистру свои аргументы. Операции и сравнения без учёта регистра будут точными, если обе строки содержат только символы 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::fromBase64Encoding() и QByteArray::fromBase64() игнорируют параметры KeepTrailingEquals и OmitTrailingEquals. Если указан параметр IgnoreBase64DecodingErrors, они не будут отмечать ошибки в случае отсутствия завершающих символов равно или их избытка. Если указан AbortOnBase64DecodingErrors, то ввод должен либо не содержать заполнения, либо содержать правильное количество знаков равно.

Это перечисление было введено или изменено в 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 предоставляет итератор non-const в стиле STL для QByteArray.

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

typedef QByteArray::reverse_iterator

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

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

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

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

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

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

Например:

void process(const QByteArray &);

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

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

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

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

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

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, создаётся массив байтов с нулевым значением.

Если 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.

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 = Qt::CaseSensitive) const

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

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

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

int QByteArray::compare(const QByteArray &a, Qt::CaseSensitivity cs = Qt::CaseSensitive) 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, QByteArray::Base64Options options)

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

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

Например:

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

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

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

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

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

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

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

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

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

Например:

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

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

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

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

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

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.

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 не найдено.

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

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

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.

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

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

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