Класс QByteArray

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

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

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

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

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

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

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

Макросы

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

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

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

Помимо QByteArray, Qt также предоставляет класс QString для хранения строковых данных. Для большинства целей QString — это класс, который следует использовать. Он хранит 16-битные символы Unicode, что упрощает хранение символов, отличных от ASCII/Latin-1, в вашем приложении. Кроме того, QString используется во всём API Qt. Два основных случая, когда QByteArray уместен, — это когда вам необходимо хранить сырые двоичные данные и когда критически важна экономия памяти (например, с Qt для Embedded 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 из функции очень быстрым. Если изменён экземпляр с совместным использованием, он будет скопирован (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 — это класс с явным совместным использованием. Следовательно, если this — пустой QByteArray, то this просто будет совместно использовать данные, хранящиеся в ba. В этом случае копирование данных не выполняется, и операция занимает постоянное время. Если изменён экземпляр с совместным использованием, он будет скопирован (copy-on-write), что займёт линейное время.

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

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

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

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

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

Возвращает декодированную копию массива, закодированного в шестнадцатеричном формате 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!"

Этот метод был добавлен в 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[] = {
    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 * ожидаемый как '\0'-терминированный, приведёт к ошибке.

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

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

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

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

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

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

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

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

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

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

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

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, 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, если этот массив байтов равен null; в противном случае возвращает 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 — максимальное количество значащих цифр (знаки '0' опускаются).

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

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

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

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

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

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

Возвращает 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

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

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

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

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

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

QByteArray QByteArray::toHex() const

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

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

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

Возвращает байтовый массив, преобразованный в целое число со знаком с основанием 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

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

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

БУКВАМИ ("a" до "z" и "A" до "Z") / ЦИФРАМИ (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

Возвращает байтовый массив, преобразованный в 16-битное целое число со знаком с основанием 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

Возвращает байтовый массив, преобразованный в 32-битное беззнаковое целое число с основанием 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Данные 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)

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