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

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

QByteArray делает глубокую копию const char * данных, поэтому вы можете позже изменить её без побочных эффектов. (Если по соображениям производительности вы не хотите делать глубокую копию данных символов, используйте QByteArray::fromRawData() вместо этого.)

Другой подход заключается в установке размера массива с помощью resize() и инициализации данных побайтово. QByteArray использует индексы, начинающиеся с 0, как и массивы в C++. Для доступа к байту по определенному индексу можно использовать оператор[](). Для массивов байтов, не являющихся константными, оператор[]() возвращает ссылку на байт, который можно использовать в левой части присваивания. Например:

QByteArray ba;
ba.resize(5);
ba[0] = 0x3c;
ba[1] = 0xb8;
ba[2] = 0x64;
ba[3] = 0x18;
ba[4] = 0xca;

Для чтения без возможности изменения используется альтернативный синтаксис с функцией at():

for (int i = 0; i < ba.size(); ++i) {
    if (ba.at(i) >= 'a' && ba.at(i) <= 'f')
        cout << "Found character in range [a-f]" << endl;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

По историческим причинам, QByteArray различает массив байтов с нулевым значением и пустой массив байтов. Нулевой массив байтов — это массив байтов, инициализированный с помощью конструктора по умолчанию 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(), операторы <(), <=(), >(), >=(), toLower() и toUpper().

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

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

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

enum QByteArray::Base64Optionflags QByteArray::Base64Options

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

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

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

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

typedef QByteArray::const_iterator

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

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

typedef QByteArray::const_reverse_iterator

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

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

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

typedef QByteArray::iterator

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

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

typedef 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, конструируется нулевой массив байтов.

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

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

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

QByteArray::QByteArray(int size, char ch)

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

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

QByteArray::QByteArray(const QByteArray &other)

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

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

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

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

Обычно эта операция не страдает от накладных расходов на выделение памяти, потому что 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[]().

iterator QByteArray::begin()

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

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

const_iterator QByteArray::begin() const

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

int QByteArray::capacity() const

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

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

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

const_iterator QByteArray::cbegin() const

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

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

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

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

void QByteArray::clear()

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

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

const_iterator QByteArray::constBegin() const

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

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

const char *QByteArray::constData() const

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

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

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

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

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

const_reverse_iterator QByteArray::crbegin() const

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

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

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

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

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

iterator QByteArray::end()

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

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

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

Возвращает декодированную копию массива hex 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[] = {
    0x00, 0x00, 0x03, 0x84, 0x78, 0x9c, 0x3b, 0x76,
    0xec, 0x18, 0xc3, 0x31, 0x0a, 0xf1, 0xcc, 0x99,
    ...
    0x6d, 0x5b
};

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

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

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

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

bool QByteArray::isEmpty() const

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

Пример:

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

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

bool QByteArray::isNull() const

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

Пример:

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

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

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

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

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

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

QByteArray QByteArray::left(int len) const

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

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

Пример:

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

См. также right(), mid(), startsWith(), и 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().

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

reverse_iterator QByteArray::rbegin()

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

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

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

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

reverse_iterator QByteArray::rend()

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

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

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

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

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

QByteArray QByteArray::simplified() const

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

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

Пример:

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

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

int QByteArray::size() const

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

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

Пример:

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

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

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

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

void QByteArray::squeeze()

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

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

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

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

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

Пример:

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

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

bool QByteArray::startsWith(char ch) const

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

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

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

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

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

void QByteArray::swap(QByteArray &other)

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

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

QByteArray QByteArray::toBase64() const

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

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

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

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

QByteArray QByteArray::toBase64(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 = Q_NULLPTR) const

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

Возвращает 0.0, если преобразование не удалось.

Если ok не равен 0: если произошла ошибка преобразования, *ok устанавливается в false; в противном случае *ok устанавливается в true.

QByteArray string("1234.56");
double a = string.toDouble();   // a == 1234.56

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

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

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

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

Возвращает 0.0, если преобразование не удалось.

Если ok не равен 0: если произошла ошибка преобразования, *ok устанавливается в false; в противном случае *ok устанавливается в true.

Примечание: Преобразование числа выполняется в стандартном 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 = Q_NULLPTR, int base = 10) const

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

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

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

Если ok не равен 0: если произошла ошибка преобразования, *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 = Q_NULLPTR, int base = 10) const

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

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

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

Если ok не равен 0: если произошла ошибка преобразования, *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 = Q_NULLPTR, int base = 10) const

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

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

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

Если ok не равен 0: если произошла ошибка преобразования, *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"

См. также 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 = Q_NULLPTR, int base = 10) const

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

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

Возвращает 0, если преобразование завершается неудачно.

Если ok не равен 0: если произошла ошибка преобразования, *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 = Q_NULLPTR, int base = 10) const

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

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

Возвращает 0, если преобразование завершается неудачно.

Если ok не равен 0: если произошла ошибка преобразования, *ok устанавливается в false; в противном случае *ok устанавливается в true.

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

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

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

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

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

Возвращает 0, если преобразование завершается неудачно.

Если ok не равен 0: если произошла ошибка преобразования, *ok устанавливается в false; в противном случае *ok устанавливается в true.

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

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

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

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

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

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

Возвращает 0, если преобразование завершается неудачно.

Если ok не равен 0: если произошла ошибка преобразования, *ok устанавливается в false; в противном случае *ok устанавливается в true.

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

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

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

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

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

Возвращает 0, если преобразование завершается неудачно.

Если ok не равен 0: если произошла ошибка преобразования, *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"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QByteRef QByteArray::operator[](int i)

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

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

Пример:

QByteArray ba;
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");