Класс QByteArray

Класс 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]" << endl;
}

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

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

QByteArray может содержать байты '\0'. Функция size() всегда возвращает размер всего массива, включая вложенные байты '\0', но исключая завершающий '\0', добавляемый QByteArray. Например:

QByteArray ba1("ca\0r\0t");
ba1.size();                     // Returns 2.
ba1.constData();                // Returns "ca" with terminating \0.

QByteArray ba2("ca\0r\0t", 3);
ba2.size();                     // Returns 3.
ba2.constData();                // Returns "ca\0" with terminating \0.

QByteArray ba3("ca\0r\0t", 4);
ba3.size();                     // Returns 4.
ba3.constData();                // Returns "ca\0r" with terminating \0.

const char cart[] = {'c', 'a', '\0', 'r', '\0', 't'};
QByteArray ba4(QByteArray::fromRawData(cart, 6));
ba4.size();                     // Returns 6.
ba4.constData();                // Returns "ca\0r\0t" without terminating \0.

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

После вызова resize() значения новых байтов не определены. Чтобы установить все байты в определённое значение, вызовите fill().

Чтобы получить указатель на фактические данные символов, вызовите data() или constData(). Эти функции возвращают указатель на начало данных. Указатель гарантированно остаётся действительным до вызова неконстантной функции для QByteArray. Также гарантируется, что данные завершаются байтом '\0', если только QByteArray не была создана из сырых данных. Этот байт '\0' автоматически добавляется QByteArray и не учитывается при вычислении size().

QByteArray предоставляет следующие базовые функции для изменения данных байтов: append(), prepend(), insert(), replace() и remove(). Например:

QByteArray x("and");
x.prepend("rock ");         // x == "rock and"
x.append(" roll");          // x == "rock and roll"
x.replace(5, 3, "&");       // x == "rock & roll"

В функциях replace() и remove() первые два аргумента — это позиция, с которой начинается удаление, и количество байтов, которые нужно удалить.

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

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

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

QByteArray ba("We must be <b>bold</b>, very <b>bold</b>");
int j = 0;
while ((j = ba.indexOf("<b>", j)) != -1) {
    cout << "Found <b> tag at index position " << j << endl;
    ++j;
}

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

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

По историческим причинам QByteArray различает массив байтов со значением null и пустой массив байтов. Нулевой массив байтов — это массив байтов, инициализированный с помощью конструктора по умолчанию 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() возвращает указатель на символ '\0' для нулевого массива байтов (не нулевой указатель), и QByteArray() сравнивается с QByteArray(""). Рекомендуется всегда использовать isEmpty() и избегать isNull().

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

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

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

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

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

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

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

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

Перечисление QByteArray::Base64Optionflags QByteArray::Base64Options

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

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

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

Тип Base64Options является псевдонимом для QFlags<Base64Option>. Он хранит сочетание значений Base64Option.

Тип QByteArray::const_iterator

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

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

Тип QByteArray::const_reverse_iterator

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

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

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

Тип QByteArray::iterator

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

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

Тип QByteArray::reverse_iterator

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

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

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

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

QByteArray::QByteArray()

Конструирует пустой массив байтов.

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

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

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

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

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

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

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

QByteArray::QByteArray(int size, char ch)

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

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

QByteArray::QByteArray(const QByteArray &other)

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

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

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

QByteArray::QByteArray(QByteArray &&other)

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

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

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(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(char ch)

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

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

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

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

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

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

char QByteArray::at(int i) const

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

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

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

char QByteArray::back() const

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

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

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

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

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

QByteRef QByteArray::back()

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

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

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

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

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

QByteArray::iterator QByteArray::begin()

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

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

QByteArray::const_iterator QByteArray::begin() const

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

int QByteArray::capacity() const

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

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

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

QByteArray::const_iterator QByteArray::cbegin() const

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

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

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

QByteArray::const_iterator QByteArray::cend() const

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

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

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

void QByteArray::chop(int n)

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

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

Пример:

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

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

QByteArray QByteArray::chopped(int len) const

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

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

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

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

void QByteArray::clear()

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

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

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

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

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

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

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

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

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

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

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

QByteArray::const_iterator QByteArray::constBegin() const

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

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

const char *QByteArray::constData() const

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

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

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

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

QByteArray::const_iterator QByteArray::constEnd() const

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

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

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

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

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

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

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

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

bool QByteArray::contains(char ch) const

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

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

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

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

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

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

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

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

int QByteArray::count(char ch) const

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

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

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

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 = '%')

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

См. также 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(const char *str, int from = 0) const

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

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

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 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, 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, char ch)

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

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

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

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

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

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

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

bool QByteArray::isEmpty() const

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

Пример:

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

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

bool QByteArray::isLower() const

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

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

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

bool QByteArray::isNull() const

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

Пример:

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

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

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

bool QByteArray::isUpper() const

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

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

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

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

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

Пример:

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

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

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

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

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

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 QString &str, int from = -1) const

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

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

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

Если truncate истинно и размер массива байтов больше 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(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.

QByteArray &QByteArray::prepend(char ch)

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

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

void QByteArray::push_back(const QByteArray &other)

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

void QByteArray::push_back(const char *str)

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

Аналогично append(str).

void QByteArray::push_back(char ch)

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

Аналогично append(ch).

void QByteArray::push_front(const QByteArray &other)

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

void QByteArray::push_front(const char *str)

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

Аналогично prepend(str).

void QByteArray::push_front(char ch)

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

Аналогично prepend(ch).

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, int alen)

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

Заменяет len байтов с индекса pos на alen байтов из строки after. Строка after может содержать символы '\0'.

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

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

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

Заменяет len байтов с индексом pos на строку с нулевым завершением after.

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

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

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

Если truncate истинно и размер массива байтов больше 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(ushort n, int base = 10)

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

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

QByteArray &QByteArray::setNum(short n, int base = 10)

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

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

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 не указан, неудача сообщается, устанавливая *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 не указан, неудача сообщается, устанавливая *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 типа 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 тип qlonglong, используя основание 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 тип 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 тип uint, используя основание 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 тип ulong, используя основание 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+=(const char *str)

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

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

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

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

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

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 QByteArray &other)

Присваивает other этому байтовому массиву и возвращает ссылку на этот байтовый массив.

QByteArray &QByteArray::operator=(const char *str)

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

Присваивает str этому байтовому массиву.

QByteArray &QByteArray::operator=(QByteArray &&other)

Перемещающее присваивание other этому экземпляру QByteArray.

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

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[](uint i) const

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

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

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

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

QByteRef QByteArray::operator[](uint i)

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

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