Класс QByteArray

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

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

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

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

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

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

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

Макросы

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

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

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

Помимо QByteArray, Qt также предоставляет класс QString для хранения строковых данных. Для большинства целей, QString — это класс, который вам нужно использовать. Он хранит 16-битные символы Юникода, что упрощает хранение символов, не являющихся ASCII/Latin-1, в вашем приложении. Кроме того, QString используется во всей API Qt. Два основных случая, когда QByteArray подходит, — это когда вам нужно хранить сырые двоичные данные и когда критична экономия памяти (например, с Qt для встраиваемой Linux).

Один из способов инициализации QByteArray — просто передать const char * в его конструктор. Например, следующий код создаёт массив байтов размером 5, содержащий данные "Hello":

QByteArray ba("Hello");

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

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

Другой подход заключается в установке размера массива с помощью resize() и инициализации данных байт за байтом. QByteArray использует индексы, начинающиеся с 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() может быть быстрее, чем оператор[](), так как он никогда не вызывает глубокую копию.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В QByteArray понятие верхнего и нижнего регистра, а также того, какой символ больше или меньше другого, зависит от локали. Это влияет на функции, которые поддерживают параметр «регистронезависимое сравнение» или сравнивают или приводят к верхнему/нижнему регистру свои аргументы. Регистронезависимые операции и сравнения будут точными, если обе строки содержат только символы ASCII. (Если $LC_CTYPE установлено, большинство систем Unix действуют «правильно».) Функции, на которые это влияет, включают contains(), indexOf(), lastIndexOf(), operator<(), operator<=(), operator>(), operator>=(), 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, полученных по оператору OR.

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

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

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

typedef QByteArray::reverse_iterator

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

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

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

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

QByteArray::QByteArray()

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

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

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

Конструирует массив байтов, содержащий первые size байты массива data.

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

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

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

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

QByteArray::QByteArray(int size, char ch)

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

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

QByteArray::QByteArray(const QByteArray &other)

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

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

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

QByteArray::QByteArray(QByteArray &&other)

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

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

QByteArray::~QByteArray()

Уничтожает массив байтов.

QByteArray &QByteArray::append(const QByteArray &ba)

Добавляет массив байтов ba в конец этого массива байтов.

Пример:

QByteArray x("free");
QByteArray y("dom");
x.append(y);
// x == "freedom"

Это то же самое, что insert(size(), ba).

Примечание: QByteArray — класс с неявным совместным использованием. Следовательно, если вы добавляете в пустой массив байтов, то массив байтов просто будет совместно использовать данные, содержащиеся в ba. В этом случае копирование данных не выполняется, занимает постоянное время. Если общий экземпляр изменяется, он копируется (copy-on-write), занимая линейное время.

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

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

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

QByteArray &QByteArray::append(int count, char ch)

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

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

Если count отрицательное или нулевое, ничего не добавляется в массив байтов.

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

QByteArray &QByteArray::append(const char *str)

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

Добавляет строку str в этот массив байтов.

QByteArray &QByteArray::append(const char *str, int len)

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

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

Если len отрицательное, длина строки будет определена автоматически с помощью qstrlen(). Если len равно нулю или str равно null, ничего не добавляется в массив байтов. Убедитесь, что len не больше, чем str.

QByteArray &QByteArray::append(char ch)

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

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

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

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

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

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

char QByteArray::at(int i) const

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

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

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

char QByteArray::back() const

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

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

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

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

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

QByteRef QByteArray::back()

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

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

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

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

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

QByteArray::iterator QByteArray::begin()

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

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

QByteArray::const_iterator QByteArray::begin() const

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

int QByteArray::capacity() const

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

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

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

QByteArray::const_iterator QByteArray::cbegin() const

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

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

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

QByteArray::const_iterator QByteArray::cend() const

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

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

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

void QByteArray::chop(int n)

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

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

Пример:

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

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

QByteArray QByteArray::chopped(int len) const

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

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

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

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

void QByteArray::clear()

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

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

QByteArray::const_iterator QByteArray::constBegin() const

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

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

const char *QByteArray::constData() const

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

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

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

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

QByteArray::const_iterator QByteArray::constEnd() const

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

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

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

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

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

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

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

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

bool QByteArray::contains(char ch) const

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

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

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

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

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

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

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

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

int QByteArray::count(char ch) const

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

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

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

int QByteArray::count() const

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

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

QByteArray::const_reverse_iterator QByteArray::crbegin() const

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

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

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

QByteArray::const_reverse_iterator QByteArray::crend() const

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

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

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

char *QByteArray::data()

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

Пример:

QByteArray ba("Hello world");
char *data = ba.data();
while (*data) {
    cout << "[" << *data << "]" << endl;
    ++data;
}

Указатель остается действительным, пока массив байтов не перераспределён или не уничтожен. Для чтения, constData() быстрее, потому что никогда не вызывает глубокую копию.

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

Следующий пример создает копию char*, возвращённого data(), но он повредит кучу и приведёт к сбою, потому что не выделяет байт для '\0' в конце:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size()];
strcpy(data, text.data());
delete [] data;

Этот пример выделяет нужное количество места:

QString tmp = "test";
QByteArray text = tmp.toLocal8Bit();
char *data = new char[text.size() + 1];
strcpy(data, text.data());
delete [] data;

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

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

const char *QByteArray::data() const

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

QByteArray::iterator QByteArray::end()

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

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

QByteArray::const_iterator QByteArray::end() const

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

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

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

Пример:

QByteArray url("http://qt-project.org/doc/qt-5.0/qtdoc/index.html");
if (url.endsWith(".html"))
    ...

См. также startsWith() и right().

bool QByteArray::endsWith(char ch) const

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

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

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

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

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

QByteArray &QByteArray::fill(char ch, int size = -1)

Устанавливает каждый байт в массиве байтов на символ ch. Если size отличается от -1 (по умолчанию), массив байтов предварительно изменяет свой размер на size.

Пример:

QByteArray ba("Istambul");
ba.fill('o');
// ba == "oooooooo"

ba.fill('X', 2);
// ba == "XX"

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

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

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

Например:

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

Алгоритм, используемый для декодирования закодированных в Base64 данных, определён в RFC 4648.

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

[static] QByteArray QByteArray::fromBase64(const QByteArray &base64, QByteArray::Base64Options options)

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

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

Например:

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

Алгоритм, используемый для декодирования закодированных в Base64 данных, определён в RFC 4648.

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

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

[static] QByteArray QByteArray::fromCFData(CFDataRef data)

Создаёт новый QByteArray, содержащий копию CFData data.

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

См. также fromRawCFData(), fromRawData(), toRawCFData() и toCFData().

[static] QByteArray QByteArray::fromHex(const QByteArray &hexEncoded)

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

Например:

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

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

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

Создаёт новый QByteArray, содержащий копию NSData data.

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

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

[static] QByteArray QByteArray::fromPercentEncoding(const QByteArray &input, char percent = '%')

Возвращает декодированную копию кодированного в процентах URI/URL-стиля input. Параметр percent позволяет заменить символ '%' на другой (например, '_' или '=').

Например:

QByteArray text = QByteArray::fromPercentEncoding("Qt%20is%20great%33");
text.data();            // returns "Qt is great!"

Примечание: При некорректном вводе (например, строка, содержащая последовательность "%G5", которая не является допустимым шестнадцатеричным числом), вывод также будет некорректным. Например, последовательность "%G5" может быть декодирована как 'W'.

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

См. также toPercentEncoding() и QUrl::fromPercentEncoding().

[static] QByteArray QByteArray::fromRawCFData(CFDataRef data)

Создаёт QByteArray, использующий байты CFData data.

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

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

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

См. также fromCFData(), fromRawData(), toRawCFData(), и toCFData().

[static] QByteArray QByteArray::fromRawData(const char *data, int size)

Создаёт QByteArray, использующий первые size байтов массива data. Байты не копируются. QByteArray будет содержать указатель data. Вызывающая сторона гарантирует, что data не будет удалён или изменён, пока существует этот QByteArray и любые его копии, которые не были изменены. Другими словами, поскольку QByteArray — это класс с неявным совместным использованием, и экземпляр, возвращаемый этой функцией, содержит указатель data, вызывающая сторона не должна удалять data или изменять его напрямую, пока возвращаемый QByteArray и любые копии существуют. Однако QByteArray не принимает владения data, поэтому деструктор QByteArray никогда не будет удалять исходные data, даже когда уничтожается последний QByteArray, ссылающийся на data.

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

Вот пример того, как читать данные с помощью QDataStream в памяти без копирования исходных данных в QByteArray:

 static const char mydata[] = {
    '\x00', '\x00', '\x03', '\x84', '\x78', '\x9c', '\x3b', '\x76',
    '\xec', '\x18', '\xc3', '\x31', '\x0a', '\xf1', '\xcc', '\x99',
    ...
    '\x6d', '\x5b'
};

QByteArray data = QByteArray::fromRawData(mydata, sizeof(mydata));
QDataStream in(&data, QIODevice::ReadOnly);
...

Предупреждение: Байтовый массив, созданный с помощью fromRawData(), не является нуль-терминированным, если только исходные данные не содержат символ 0 в позиции size. Хотя это не имеет значения для QDataStream или функций вроде indexOf(), передача байтового массива функции, принимающей const char * ожидаемый нуль-терминированный, закончится ошибкой.

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

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

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

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

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

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

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

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

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

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

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

char QByteArray::front() const

Возвращает первый символ в массиве байтов. То же, что и at(0).

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

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

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

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

QByteRef QByteArray::front()

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

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

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

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

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

int QByteArray::indexOf(const QByteArray &ba, int from = 0) const

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

Пример:

QByteArray x("sticky question");
QByteArray y("sti");
x.indexOf(y);               // returns 0
x.indexOf(y, 1);            // returns 10
x.indexOf(y, 10);           // returns 10
x.indexOf(y, 11);           // returns -1

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

int QByteArray::indexOf(const char *str, int from = 0) const

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

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

int QByteArray::indexOf(char ch, int from = 0) const

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

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

Пример:

QByteArray ba("ABCBA");
ba.indexOf("B");            // returns 1
ba.indexOf("B", 1);         // returns 1
ba.indexOf("B", 2);         // returns 3
ba.indexOf("X");            // returns -1

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

int QByteArray::indexOf(const QString &str, int from = 0) const

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

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

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

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

QByteArray &QByteArray::insert(int i, const QByteArray &ba)

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

Пример:

QByteArray ba("Meal");
ba.insert(1, QByteArray("ontr"));
// ba == "Montreal"

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

QByteArray &QByteArray::insert(int i, int count, char ch)

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

Вставляет count копий символа ch в позицию с индексом i в массиве байтов.

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

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

QByteArray &QByteArray::insert(int i, const char *str)

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

Вставляет строку str в позицию i в массиве байтов.

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

QByteArray &QByteArray::insert(int i, const char *str, int len)

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

Вставляет len байтов строки str в позицию i в массиве байтов.

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

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

QByteArray &QByteArray::insert(int i, char ch)

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

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

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

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

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

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

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

bool QByteArray::isEmpty() const

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

Пример:

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

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

bool QByteArray::isNull() const

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

Пример:

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

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

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

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

QByteArray QByteArray::left(int len) const

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

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

Пример:

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

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

QByteArray QByteArray::leftJustified(int width, char fill = ' ', bool truncate = false) const

Возвращает массив байтов размером width, содержащий этот массив байтов, дополненный символом fill.

Если truncate равно false и size() массива байтов больше, чем width, то возвращаемый массив байтов — копия этого массива байтов.

Если truncate равно true и size() массива байтов больше, чем width, то любые байты в копии массива байтов после позиции width удаляются, и возвращается копия.

Пример:

QByteArray x("apple");
QByteArray y = x.leftJustified(8, '.');   // y == "apple..."

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

int QByteArray::length() const

То же, что и size().

QByteArray QByteArray::mid(int pos, int len = -1) const

Возвращает массив байтов, содержащий len байтов из этого массива байтов, начиная с позиции pos.

Если len равно -1 (по умолчанию), или pos + len >= size(), возвращает массив байтов, содержащий все байты, начиная с позиции pos до конца массива байтов.

Пример:

QByteArray x("Five pineapples");
QByteArray y = x.mid(5, 4);     // y == "pine"
QByteArray z = x.mid(5);        // z == "pineapples"

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

[static] QByteArray QByteArray::number(int n, int base = 10)

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

Пример:

int n = 63;
QByteArray::number(n);              // returns "63"
QByteArray::number(n, 16);          // returns "3f"
QByteArray::number(n, 16).toUpper();  // returns "3F"

Примечание: Формат числа не локализован; используется C-по умолчанию, независимо от локали пользователя.

См. также setNum() и toInt().

[static] QByteArray QByteArray::number(uint n, int base = 10)

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

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

[static] QByteArray QByteArray::number(qlonglong n, int base = 10)

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

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

[static] QByteArray QByteArray::number(qulonglong n, int base = 10)

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

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

[static] QByteArray QByteArray::number(double n, char f = 'g', int prec = 6)

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

Возвращает массив байтов, содержащий отформатированное значение n в формате f с точностью prec.

Аргумент n форматируется в соответствии со спецификацией формата f, которая имеет значение g по умолчанию и может быть любой из следующих:

При использовании 'e', 'E' и 'f', prec — количество цифр после десятичной точки. При использовании 'g' и 'G', prec — максимальное количество значащих цифр (завершающие нули опущаются).

QByteArray ba = QByteArray::number(12.3456, 'E', 3);
// ba == 1.235E+01

Примечание: Формат числа не локализован; используется локаль по умолчанию C независимо от локали пользователя.

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

QByteArray &QByteArray::prepend(const QByteArray &ba)

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

Пример:

QByteArray x("ship");
QByteArray y("air");
x.prepend(y);
// x == "airship"

Это то же самое, что insert(0, ba).

Примечание: QByteArray — класс с неявным совместным использованием. Следовательно, если вы добавляете в начало пустой массив байтов, то массив байтов просто будет совместно использовать данные, содержащиеся в ba. В этом случае копирование данных не выполняется, что занимает постоянное время. Если изменён экземпляр, используемый совместно, он будет скопирован (копирование при записи), что займёт линейное время.

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

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

QByteArray &QByteArray::prepend(int count, char ch)

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

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

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

QByteArray &QByteArray::prepend(const char *str)

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

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

QByteArray &QByteArray::prepend(const char *str, int len)

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

Добавляет len байтов строки str в начало этого массива байтов.

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

QByteArray &QByteArray::prepend(char ch)

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

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

void QByteArray::push_back(const QByteArray &other)

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

void QByteArray::push_back(const char *str)

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

То же самое, что и append(str).

void QByteArray::push_back(char ch)

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

То же самое, что и append(ch).

void QByteArray::push_front(const QByteArray &other)

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

void QByteArray::push_front(const char *str)

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

То же самое, что и prepend(str).

void QByteArray::push_front(char ch)

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

То же самое, что и prepend(ch).

QByteArray::reverse_iterator QByteArray::rbegin()

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

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

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

QByteArray::const_reverse_iterator QByteArray::rbegin() const

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

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

QByteArray &QByteArray::remove(int pos, int len)

Удаляет len байтов из массива, начиная с индекса pos, и возвращает ссылку на массив.

Если pos выходит за пределы диапазона, ничего не происходит. Если pos допустимо, но pos + len больше размера массива, массив усекается до позиции pos.

Пример:

QByteArray ba("Montreal");
ba.remove(1, 4);
// ba == "Meal"

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

QByteArray::reverse_iterator QByteArray::rend()

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

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

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

QByteArray::const_reverse_iterator QByteArray::rend() const

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

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

QByteArray QByteArray::repeated(int times) const

Возвращает копию этого массива байтов, повторив его указанное количество раз times.

Если times меньше 1, возвращается пустой массив байтов.

Пример:

QByteArray ba("ab");
ba.repeated(4);             // returns "abababab"

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

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

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

Пример:

QByteArray x("Say yes!");
QByteArray y("no");
x.replace(4, 3, y);
// x == "Say no!"

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

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

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

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

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

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

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

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

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

QByteArray &QByteArray::replace(char before, const char *after)

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

Заменяет каждое вхождение символа before строкой after.

QByteArray &QByteArray::replace(char before, const QByteArray &after)

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

Заменяет каждое вхождение символа before массивом байтов after.

QByteArray &QByteArray::replace(const char *before, const char *after)

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

Заменяет каждое вхождение строки before строкой after.

QByteArray &QByteArray::replace(const char *before, int bsize, const char *after, int asize)

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

Заменяет каждое вхождение строки before строкой after. Так как размеры строк заданы bsize и asize, они могут содержать нулевые символы и не должны быть нуль-терминированными.

QByteArray &QByteArray::replace(const QByteArray &before, const QByteArray &after)

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

Заменяет все вхождения массива байтов before на массив байтов after.

Пример:

QByteArray ba("colour behaviour flavour neighbour");
ba.replace(QByteArray("ou"), QByteArray("o"));
// ba == "color behavior flavor neighbor"

QByteArray &QByteArray::replace(const QByteArray &before, const char *after)

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

Заменяет все вхождения массива байтов before на строку after.

QByteArray &QByteArray::replace(const char *before, const QByteArray &after)

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

Заменяет все вхождения строки before на массив байтов after.

QByteArray &QByteArray::replace(char before, char after)

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

Заменяет все вхождения символа before на символ after.

QByteArray &QByteArray::replace(const QString &before, const char *after)

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

Заменяет все вхождения строки before на строку after.

QByteArray &QByteArray::replace(char before, const QString &after)

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

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

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

void QByteArray::reserve(int size)

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

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

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

void QByteArray::resize(int size)

Устанавливает размер массива байтов в size байтов.

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

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

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

QByteArray QByteArray::right(int len) const

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

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

Пример:

QByteArray x("Pineapple");
QByteArray y = x.right(5);
// y == "apple"

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

QByteArray QByteArray::rightJustified(int width, char fill = ' ', bool truncate = false) const

Возвращает массив байтов размером width, содержащий символ fill, за которым следует этот массив байтов.

Если truncate равно false и размер массива байтов больше width, то возвращаемый массив байтов является копией этого массива байтов.

Если truncate равно true и размер массива байтов больше width, то результирующий массив байтов усекается на позиции width.

Пример:

QByteArray x("apple");
QByteArray y = x.rightJustified(8, '.');    // y == "...apple"

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

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

Устанавливает массив байтов в печатное значение n в системе счисления base (по умолчанию 10) и возвращает ссылку на массив байтов. Значение base может быть любым значением от 2 до 36. Для систем счисления, отличных от 10, n обрабатывается как целое без знака.

Пример:

QByteArray ba;
int n = 63;
ba.setNum(n);           // ba == "63"
ba.setNum(n, 16);       // ba == "3f"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

QByteArray &QByteArray::setNum(float n, char f = 'g', int prec = 6)

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

Устанавливает массив байтов в печатное значение n, отформатированное с использованием формата f с точностью prec, и возвращает ссылку на массив байтов.

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

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

QByteArray &QByteArray::setNum(double n, char f = 'g', int prec = 6)

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

Устанавливает массив байтов в печатное значение n, отформатированное с использованием формата f с точностью prec, и возвращает ссылку на массив байтов.

Формат f может быть любым из следующих:

При использовании 'e', 'E' и 'f', prec — это количество цифр после десятичной точки. При использовании 'g' и 'G', prec — максимальное количество значащих цифр (завершающие нули опускаются).

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

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

QByteArray &QByteArray::setRawData(const char *data, uint size)

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

Эта функция может быть использована вместо fromRawData() для повторного использования существующих объектов QByteArray с целью экономии памяти, избегая повторных выделений.

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

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

void QByteArray::shrink_to_fit()

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

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

QByteArray QByteArray::simplified() const

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

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

Пример:

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

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

int QByteArray::size() const

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

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

Пример:

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

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

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

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

void QByteArray::squeeze()

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

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

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

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

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

Пример:

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

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

bool QByteArray::startsWith(char ch) const

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

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

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

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

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

void QByteArray::swap(QByteArray &other)

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

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

QByteArray QByteArray::toBase64() const

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

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

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

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

QByteArray QByteArray::toBase64(QByteArray::Base64Options options) const

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

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

QByteArray text("<p>Hello?</p>");
text.toBase64(QByteArray::Base64Encoding | QByteArray::OmitTrailingEquals);      // returns "PHA+SGVsbG8/PC9wPg"
text.toBase64(QByteArray::Base64Encoding);                                       // returns "PHA+SGVsbG8/PC9wPg=="
text.toBase64(QByteArray::Base64UrlEncoding);                                    // returns "PHA-SGVsbG8_PC9wPg=="
text.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);   // returns "PHA-SGVsbG8_PC9wPg"

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

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

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

CFDataRef QByteArray::toCFData() const

Создаёт CFData из QByteArray. Вызывающий код владеет объектом CFData и отвечает за его освобождение.

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

См. также toRawCFData(), fromCFData(), fromRawCFData() и fromRawData().

double QByteArray::toDouble(bool *ok = nullptr) const

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

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

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

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

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

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

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

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

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

Если ok не nullptr, ошибка сообщается, устанавливая *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 = nullptr, int base = 10) const

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

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

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

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

QByteArray str("FF");
bool ok;
int hex = str.toInt(&ok, 16);     // hex == 255, ok == true
int dec = str.toInt(&ok, 10);     // dec == 0, ok == false

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

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

long QByteArray::toLong(bool *ok = nullptr, int base = 10) const

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

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

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

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

QByteArray str("FF");
bool ok;
long hex = str.toLong(&ok, 16);   // hex == 255, ok == true
long dec = str.toLong(&ok, 10);   // dec == 0, ok == false

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

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

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

qlonglong QByteArray::toLongLong(bool *ok = nullptr, int base = 10) const

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

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

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

Если ok не nullptr, неудача сообщается, установив *ok в false, а успех — установив *ok в true.

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

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

QByteArray QByteArray::toLower() const

Возвращает копию байтовой строки в нижнем регистре. Байтовая строка интерпретируется как строка в кодировке Latin-1.

Пример:

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toLower();
// y == "qt by the qt company"

См. также toUpper() и 8-битные сравнения символов.

NSData *QByteArray::toNSData() const

Создаёт NSData из QByteArray. Объект NSData автоматически освобождается.

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

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

QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude = QByteArray(), const QByteArray &include = QByteArray(), char percent = '%') const

Возвращает URI/URL-стилевую процентно-кодированную копию этой байтовой строки. Параметр percent позволяет переопределить символ '%' по умолчанию на другой.

По умолчанию эта функция будет кодировать все символы, которые не являются одним из следующих:

ALPHA ("a" до "z" и "A" до "Z") / DIGIT (0 до 9) / "-" / "." / "_" / "~"

Чтобы предотвратить кодирование символов, передайте их в exclude. Чтобы принудительно закодировать символы, передайте их в include. Символ '%' всегда кодируется.

Пример:

QByteArray text = "{a fishy string?}";
QByteArray ba = text.toPercentEncoding("{}", "s");
qDebug(ba.constData());
// prints "{a fi%73hy %73tring%3F}"

Шестнадцатеричное кодирование использует цифры от 0 до 9 и заглавные буквы от A до F.

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

См. также fromPercentEncoding() и QUrl::toPercentEncoding().

CFDataRef QByteArray::toRawCFData() const

Создаёт CFData, использующий байты QByteArray.

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

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

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

См. также toCFData(), fromRawCFData(), fromCFData() и fromRawData().

NSData *QByteArray::toRawNSData() const

Создаёт NSData, использующий байты QByteArray.

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

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

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

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

short QByteArray::toShort(bool *ok = nullptr, int base = 10) const

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

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

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

Если ok не nullptr, неудача сообщается, установив *ok в false, а успех — установив *ok в true.

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

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

std::string QByteArray::toStdString() const

Возвращает объект std::string с данными, содержащимися в этом QByteArray.

Этот оператор в основном полезен для передачи QByteArray в функцию, которая принимает объект std::string.

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

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

uint QByteArray::toUInt(bool *ok = nullptr, int base = 10) const

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

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

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

Если ok не nullptr, неудача сообщается, установив *ok в false, а успех — установив *ok в true.

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

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

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

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

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

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

Если ok не nullptr, неудача сообщается, установив *ok в false, а успех — установив *ok в true.

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

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

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

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

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

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

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

Если ok не nullptr, неудача сообщается, установив *ok в false, а успех — установив *ok в true.

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

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

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

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

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

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

Если ok не nullptr, неудача сообщается, установив *ok в false, а успех — установив *ok в true.

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

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

QByteArray QByteArray::toUpper() const

Возвращает копию байтовой строки в верхнем регистре. Байтовая строка интерпретируется как строка в кодировке Latin-1.

Пример:

QByteArray x("Qt by THE QT COMPANY");
QByteArray y = x.toUpper();
// y == "QT BY THE QT COMPANY"

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

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