QByteArray 类

成员函数文档

返回字节数组中存储的数据的指针。该指针可以用来访问组成数组的数据。数据以 '\0' 结尾。

只要没有发生断开连接，并且 QByteArray 没有被修改，指针都保持有效。

此操作符主要用于将字节数组传递给接受 const char * 的函数。

您可以在编译应用程序时通过定义 QT_NO_CAST_FROM_BYTEARRAY 来禁用此操作符。

注意： QByteArray 可以存储任何字节值，包括 '\0's，但大多数接受 char * 参数的函数都假设数据在遇到第一个 '\0' 处结束。

另请参阅 constData。

返回包含此字节数组前 len 个字节的字节数组。

如果您知道 len 不会超出范围，则在新的代码中使用 first()，因为它更快。

如果 len 大于 size()，则返回整个字节数组。

如果 len 小于 0，则返回空的 QByteArray。

另请参阅 first()，last()，startsWith()，chopped()，chop() 和 truncate。

返回一个包含此字节数组最后 len 个字节的字节数组。

如果您知道 len 不会超出范围，请在新的代码中使用 last()，因为它更快。

如果 len 大于 size()，则返回整个字节数组。

如果 len 小于 0，则返回空的 QByteArray。

另请参阅endsWith()，last()，first()，sliced()，chopped()，chop() 和 truncate()。

返回一个包含从位置 pos 开始的 len 个字节的字节数组。

如果您知道 pos 和 len 不会超出范围，请在新的代码中使用 sliced()，因为它更快。

如果 len 为 -1（默认值），或 pos + len >= size()，则返回从位置 pos 开始直到字节数组末尾的所有字节的字节数组。

另请参阅first()，last()，sliced()，chopped()，chop() 和 truncate()。

返回字节数组的前 n 个字节。

示例

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

此函数是在 Qt 6.0 中引入的。

另请参阅last()，sliced()，startsWith()，chopped()，chop() 和 truncate()。

返回字节数组的最后 n 个字节。

示例

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

此函数是在 Qt 6.0 中引入的。

另请参阅first()，sliced()，endsWith()，chopped()，chop() 和 truncate()。

返回一个字节数组，包含从位置 pos 开始的 n 个字节的此对象。

示例

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

此函数是在 Qt 6.0 中引入的。

另请参考：first()，last()，chopped()，chop()，以及 truncate。

这是一个重载函数。

返回一个字节数组，包含从位置 pos 开始，直到对象末尾的字节。

此函数是在 Qt 6.0 中引入的。

另请参阅first()，last()，sliced()，chopped()，chop() 和 truncate()。

返回一个字节数组，包含此字节数组最左边的 size() - len 个字节。

另请参考：endsWith()，first()，last()，sliced()，chop()，以及 truncate。

这是一个重载函数。

解码以Base64编码的数组 base64，使用定义的选项 options。如果 options 包含 IgnoreBase64DecodingErrors（默认情况），则不检查输入的有效性；输入中的无效字符将被跳过，允许解码过程继续处理后续字符。如果 options 包含 AbortOnBase64DecodingErrors，则解码会在第一个无效字符处停止。

例如

void process(const QByteArray &);

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

解码Base64编码数据的算法在 RFC 4648 中定义。

返回一个包含解码数据和表示解码是否成功的标志的 QByteArrayFromBase64Result 对象。如果传入了 AbortOnBase64DecodingErrors 选项且输入数据无效，解码数据包含的内容是不确定的。

另请参阅 toBase64()。

[constexpr noexcept] QByteArray::QByteArray()

构建一个空字节数组。

另请参阅 isEmpty()。

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

构建包含数组 data 的前 size 个字节的字节数组。

如果 data 是 0，则构建一个空字节数组。

如果 size 是负数，则假定 data 指向一个以 '\0' 结尾的字符串，并动态确定其长度。

QByteArray 对字符串数据执行深度复制。

另请参阅 fromRawData()。

QByteArray::QByteArray(qsizetype size, char ch)

构建一个大小为 size 的字节数组，每个字节都设置为 ch。

另请参阅 fill()。

QByteArray::QByteArray(qsizetype size, Qt::Initialization)

构建一个大小为 size 的字节数组，内容未初始化。

[noexcept] QByteArray::QByteArray(const QByteArray &other)

构建其他对象的副本。

此操作需要 恒定时间，因为 QByteArray 是 隐式共享的。这使得从函数中返回 QByteArray 非常快。如果修改了共享实例，则它将被复制（写入时复制），耗时 线性时间。

另请参阅 operator=()。

[noexcept] QByteArray::QByteArray(QByteArray &&other)

移动构造一个 QByteArray 实例，使其指向 other 指向的同一对象。

[noexcept] 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 中的数据。在这种情况下，不执行数据复制，耗时 恒定时间。如果共享实例被修改，它将被复制（写时复制），耗时 线性时间。

如果追加的字节数组不为空，则会执行数据的深复制，耗时 线性时间。

append() 函数通常非常快（恒定时间），因为 QByteArray 在数据末尾预分配额外的空间，因此可以在每次不需要重新分配整个数组的情况下增长。

另请参阅 操作符+=，prepend 和 insert。

QByteArray &QByteArray::append(char ch)

这是一个重载函数。

将字节数据 ch 追加到此字节数组。

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

这是一个重载函数。

将 count 个字节数据 ch 追加到此字节数组，并返回对此字节数组的引用。

如果 count 为负或零，则不会向字节数组追加任何内容。

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

这是一个重载函数。

将以 '\0' 结尾的字符串 str 追加到此字节数组。

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

这是一个重载函数。

将 str 起始处的第一个 len 个字节追加到此字节数组，并返回对此字节数组的引用。追加的字节可能包括 '\0' 字节。

如果 len 为负，则假定 str 为一个 '\0' 结尾的字符串，并且通过使用 qstrlen() 自动确定要复制的长度。

如果 len 为零或 str 为空，则不会向字节数组追加任何内容。请确保 len 不超过 str。

QByteArray &QByteArray::append(QByteArrayView data)

这是一个重载函数。

将 data 追加到此字节数组。

[since 6.6] QByteArray &QByteArray::assign(QByteArrayView v)

用 v 的副本替换此字节数组的内容，并返回对此字节数组的引用。

此字节数组的大小将与 v 的大小相等。

只有当 v 的大小超过此字节数组的容量或此字节数组是共享的情况下，此函数才分配内存。

此函数首次在 Qt 6.6 中引入。

[since 6.6] QByteArray &QByteArray::assign(qsizetype n, char c)

用n次复制的c替换此字节数组的内容，并返回对这个字节数组的引用。

此字节数组的长度将等于n，它必须是非负数。

如果n超过此字节数组的容量或此字节数组是共享的，则此函数将只分配内存。

此函数首次在 Qt 6.6 中引入。

另请参阅 fill()。

[since 6.6] 模板 <typename InputIterator, QByteArray::if_input_iterator<InputIterator> = true> QByteArray &QByteArray::assign(InputIterator first, InputIterator last)

用迭代器范围 [first, last]) 中的元素副本替换此字节数组的内容，并返回对这个字节数组的引用。

此字节数组的长度将与范围 [first, last]) 中的元素数量相等。

如果范围中的元素数量超过此字节数组的容量或此字节数组是共享的，则此函数将只分配内存。

此函数首次在 Qt 6.6 中引入。

char QByteArray::at(qsizetype i) const

返回字节数组中位置i上的字节。

i必须是字节数组中的有效索引位置（即，0 <= i < size()).

另请参阅operator[]().

char QByteArray::back() const

返回字节数组中的最后一个字节。与at(size() - 1)相同。

此函数提供以便与STL兼容。

另请参阅front()、at() 和 operator[]().

char &QByteArray::back()

返回字节数组中最后一个字节的引用。与operator[](size() - 1)相同。

此函数提供以便与STL兼容。

另请参阅front()、at() 和 operator[]().

QByteArray::iterator QByteArray::begin()

返回一个指向字节数组中第一个字节的STL-style迭代器。

另请参阅constBegin() 和 end().

[noexcept] QByteArray::const_iterator QByteArray::begin() const

此函数对begin进行重载。

qsizetype QByteArray::capacity() const

返回可以在不强制重新分配的情况下存储在字节数组中的最大字节数。

此函数的唯一目的是提供一个方法来微调 QByteArray 的内存使用。一般来说，您很少需要调用此函数。如果想知道字节数组中有多少字节，请调用 size()。

另外参见reserve() 和 squeeze()。

[noexcept] QByteArray::const_iterator QByteArray::cbegin() const

返回指向字节数组中第一个字节的 const STL-style 迭代器。

另外参见begin() 和 cend()。

[noexcept] QByteArray::const_iterator QByteArray::cend() const

返回指向字节数组最后一个字节之后的 const STL-style 迭代器。

另外参见cbegin() 和 end()。

void QByteArray::chop(qsizetype n)

从字节数组末尾去除 n 个字节。

如果 n 大于 size()，则结果是一个空字节数组。

示例

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

另外参见truncate()，resize() 和 first()。

void QByteArray::clear()

清除字节数组的内容并使其为空。

另外参见resize() 和 isNull()。

[noexcept, since 6.0] int QByteArray::compare(QByteArrayView bv, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

根据此 QByteArray 是否在 QByteArrayView bv 前面、与其在同一位置或在其后面进行排序，返回小于、等于或大于零的整数值。比较是按照大小写敏感度 cs 进行的。

此函数是在 Qt 6.0 中引入的。

另外参见operator== 和 Character Case.

[noexcept] QByteArray::const_iterator QByteArray::constBegin() const

返回指向字节数组中第一个字节的 const STL-style 迭代器。

另外参见begin() 和 constEnd()。

[noexcept] const char *QByteArray::constData() const

返回指向存储在字节数组中的 const 数据的指针。此指针可用于访问组成数组的字节。除非 QByteArray 对象是从原始数据创建的，否则数据是 '\0' 结尾的。

只要没有发生断开连接，并且 QByteArray 没有被修改，指针都保持有效。

此功能主要用于将字节数组传递给接受 const char * 的函数。

注意： QByteArray 可以存储任何字节值，包括 '\0's，但大多数接受 char * 参数的函数都假设数据在遇到第一个 '\0' 处结束。

另请参阅 data()，operator[]() 和 fromRawData()。

[noexcept] QByteArray::const_iterator QByteArray::constEnd() const

返回指向字节数组最后一个字节之后的 const STL-style 迭代器。

另请参阅constBegin() 和 end().

[since 6.0] bool QByteArray::contains(QByteArrayView bv) const

如果此字节数组包含由 bv 观看的字节数序列，则返回 true；否则返回 false。

此函数是在 Qt 6.0 中引入的。

另请参阅 indexOf() 和 count()。

bool QByteArray::contains(char ch) const

这是一个重载函数。

如果字节数组中包含字节 ch，则返回 true；否则返回 false。

[since 6.0] qsizetype QByteArray::count(QByteArrayView bv) const

返回在当前字节数组中由 bv 观看的字节数序列的（可能重叠的）出现次数。

此函数是在 Qt 6.0 中引入的。

另请参阅 contains() 和 indexOf()。

qsizetype QByteArray::count(char ch) const

这是一个重载函数。

返回字节数组中字节 ch 的出现次数。

另请参阅 contains() 和 indexOf()。

[noexcept] QByteArray::const_reverse_iterator QByteArray::crbegin() const

返回一个指向字节数组开始字节（反向顺序）的 const STL-style 反向迭代器。

另请参阅 begin()，rbegin() 和 rend()。

[noexcept] QByteArray::const_reverse_iterator QByteArray::crend() const

返回一个指向字节数组末尾后（反向顺序）的 const STL-style 反向迭代器。

另请参阅 end()，rend() 和 rbegin()。

char *QByteArray::data()

返回指向字节数组中存储数据的指针。此指针可用于访问和修改数组组成的字节。数据以 '\0' 结尾，即从返回的指针后可以访问的字节数为 size() + 1，包括 '\0' 终止符。

示例

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

只要没有发生断开连接，并且 QByteArray 没有被修改，指针都保持有效。

对于只读访问，constData() 比较快，因为它不会导致发生 深复制。

此功能主要用于将字节数组传递给接受 const char * 的函数。

以下示例通过 data() 返回 char* 的副本，但由于它没有为末尾的 '\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's，但大多数接受 char * 参数的函数都假设数据在遇到第一个 '\0' 处结束。

另请参阅 constData() 和 operator[]()。

[noexcept] const char *QByteArray::data() const

这是一个重载函数。

QByteArray::iterator QByteArray::end()

返回一个指向字节数组中最后一个字节之后的STL样式迭代器。

另外参见begin() 和 constEnd()。

[noexcept] QByteArray::const_iterator QByteArray::end() const

此函数重载了end()。

[since 6.0] bool QByteArray::endsWith(QByteArrayView bv) const

如果此字节数组以由bv查看的字节序列结束，则返回true; 否则返回false。

示例

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

此函数是在 Qt 6.0 中引入的。

另请参阅startsWith() 和 last()。

bool QByteArray::endsWith(char ch) const

这是一个重载函数。

如果此字节数组以字节ch结束，则返回true; 否则返回false。

[since 6.1] QByteArray::iterator QByteArray::erase(QByteArray::const_iterator first, QByteArray::const_iterator last)

从字节数组中移除位于半开区间[ first , last )内的字符。返回一个迭代器，指向删除之前的last指向的字符。

此函数是在Qt 6.1中引入的。

[since 6.5] QByteArray::iterator QByteArray::erase(QByteArray::const_iterator it)

从字节数组中删除由 it 指示的字符。返回一个迭代器，指向删除后的下一个字符。

QByteArray ba = "abcdefg";
auto it = ba.erase(ba.cbegin()); // ba is now "bcdefg" and it points to "b"

此函数是在Qt 6.5中引入的。

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

将字节数组中的每个字节设置为ch。如果size不同於-1（默认值），字节数组将在之前调整大小至size。

示例

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

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

另请参阅resize()。

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

返回Base64数组base64的解码副本，使用由options定义的选项。如果options包含IgnoreBase64DecodingErrors（默认值），则输入不进行检查是否有效；跳过输入中的无效字符，使解码过程可以继续使用随后的字符。如果options包含AbortOnBase64DecodingErrors，则解码将在第一个无效字符处停止。

例如

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

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

解码Base64编码数据的算法在 RFC 4648 中定义。

返回解码数据，如果传递了AbortOnBase64DecodingErrors选项并且输入数据无效，则返回一个空字节数组。

另请参阅 toBase64() 和 fromBase64Encoding().

[静态] QByteArray QByteArray::fromCFData(CFDataRef data)

构造一个新的QByteArray，包含CFData data的副本。

另请参阅 fromRawCFData()，fromRawData()，toRawCFData() 和 toCFData().

[静态，自6.5起] QByteArray QByteArray::fromEcmaUint8Array(emscripten::val uint8array)

构造一个新的QByteArray，包含Uint8Array uint8array的副本。

此函数将数据从JavaScript数据缓冲区（无法从C++代码中寻址）转移到由QByteArray拥有的堆内存中。Uint8Array可以使用复制完成后释放。

参数uint8array必须是一个指向Uint8Array对象的emscripten::val引用，例如从全局JavaScript变量中获取

emscripten::val uint8array = emscripten::val::global("g_uint8array");
QByteArray byteArray = QByteArray::fromEcmaUint8Array(uint8array);

如果Uint8Array的大小超过QByteArray的最大容量，或者如果uint8array参数不是Uint8Array类型，则此函数返回一个null QByteArray。

此函数是在Qt 6.5中引入的。

另请参阅 toEcmaUint8Array().

[静态] QByteArray QByteArray::fromHex(const QByteArray &hexEncoded)

返回一个十六进制编码数组hexEncoded的解码副本。输入未进行验证；跳过输入中的无效字符，允许解码过程在后续字符中继续。

例如

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

另请参阅 toHex().

[静态] QByteArray QByteArray::fromNSData(const NSData *data)

构造一个新的QByteArray，包含NSData data的副本。

另请参阅 fromRawNSData()，fromRawData()，toNSData() 和 toRawNSData().

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

将input从URI/URL风格的百分编码解码。

返回包含解码文本的字节数组。参数percent允许使用不同于'%'（例如'_'或'='）的字符作为转义字符。相当于input.percentDecoded(percent)。

例如

QByteArray text = QByteArray::fromPercentEncoding("Qt%20is%20great%33");
qDebug("%s", text.data());      // reports "Qt is great!"

另请参阅 percentDecoded().

[静态] QByteArray QByteArray::fromRawCFData(CFDataRef data)

使用CFData的bytes构建一个QByteArray。

不复制data的bytes。

调用者保证只要这个QByteArray对象存在，CFData就不会被删除或修改。

另请参阅fromCFData()、fromRawData()、toRawCFData()和toCFData。

[静态] QByteArray QByteArray::fromRawData(const char *data, qsizetype size)

使用data数组的第一个size个bytes构建一个QByteArray。bytes不会复制。QByteArray将包含data指针。调用者保证只要这个QByteArray和任何复制存在而未被修改，data就不会被删除或修改。换句话说，因为QByteArray是一个隐式共享的类，而且这个函数返回的实例包含data指针，调用者不准修改data或者直接删除它。然而QByteArray并不著作权data，所以QByteArray析构函数永远不会删除原始data，即使最后一个引用data的QByteArray被销毁。

随后尝试修改返回的QByteArray或其任何复制的内容，在修改前将创建data数组的深拷贝。这确保原始data数组本身不会被QByteArray修改。

以下是如何在没有将原始数据复制到QByteArray中的情况下，使用QDataStream读取内存中的原始数据的示例。

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

另请参阅setRawData()、data()和constData。

[静态] QByteArray QByteArray::fromRawNSData(const NSData *data)

使用NSData的bytes构建一个QByteArray。

不复制data的bytes。

调用者保证只要这个QByteArray对象存在，NSData就不会被删除或修改。

另请参阅fromNSData()、fromRawData()、toRawNSData()和toNSData。

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

返回str字符串的QByteArray副本。

另请参阅toStdString()和QString::fromStdString。

char QByteArray::front() const

返回字节数组的第一个字节。等同于 at(0)。

此函数提供以便与STL兼容。

另请参阅 back()，at() 和 operator[]。

char &QByteArray::front()

返回对字节数组第一个字节的引用。等同于 operator[](0)。

此函数提供以便与STL兼容。

另请参阅 back()，at() 和 operator[]。

[自 6.0] qsizetype QByteArray::indexOf(QByteArrayView bv, qsizetype from = 0) const

返回在此字节数组中查看的 bv 字节序列首次出现的起始索引位置，从索引位置 from 开始搜索。如果没有找到匹配项，则返回 -1。

示例

QByteArray x("sticky question");
QByteArrayView 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

此函数是在 Qt 6.0 中引入的。

另请参阅 lastIndexOf()，contains() 和 count。

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

这是一个重载函数。

返回在此字节数组中从索引位置 from 开始搜索的字节 ch 首次出现的起始索引位置。如果没有找到匹配项，则返回 -1。

示例

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。

[自 6.0] QByteArray &QByteArray::insert(qsizetype i, QByteArrayView data)

在索引位置 i 插入 data 并返回对此字节数组的引用。

示例

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

对于大型字节数组，此操作可能较慢（线性时间），因为它需要将索引 i 及其以上的所有字节至少移动一个位置。

此数组调整大小以容纳插入。如果 i 位于数组末尾之外，则首先使用空格字符扩展数组以到达此 i。

此函数是在 Qt 6.0 中引入的。

另请参阅 append()，prepend()，replace() 和 remove。

QByteArray &QByteArray::insert(qsizetype i, const char *s)

在索引位置 i 插入 s 并返回对此字节数组的引用。

此数组调整大小以容纳插入。如果 i 位于数组末尾之外，则首先使用空格字符扩展数组以到达此 i。

函数等同于 insert(i, QByteArrayView(s))

另请参阅 append()，prepend()，replace() 和 remove。

QByteArray &QByteArray::insert(qsizetype i, const QByteArray &data)

在索引位置 i 插入 data 并返回对此字节数组的引用。

此数组调整大小以容纳插入。如果 i 位于数组末尾之外，则首先使用空格字符扩展数组以到达此 i。

另请参阅 append()，prepend()，replace() 和 remove。

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

这是一个重载函数。

在字节数组的索引位置 i 插入 count 个字节 ch 复制。

此数组调整大小以容纳插入。如果 i 位于数组末尾之外，则首先使用空格字符扩展数组以到达此 i。

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

这是一个重载函数。

在字节数组中索引位置i插入字节ch。

此数组调整大小以容纳插入。如果 i 位于数组末尾之外，则首先使用空格字符扩展数组以到达此 i。

QByteArray &QByteArray::insert(qsizetype i, const char *data, qsizetype len)

这是一个重载函数。

在字节数组中从data开始索引位置i插入len字节。

此数组调整大小以容纳插入。如果 i 位于数组末尾之外，则首先使用空格字符扩展数组以到达此 i。

[noexcept] bool QByteArray::isEmpty() const

如果字节数组大小为0，则返回true；否则返回false。

示例

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

另请参阅size。

bool QByteArray::isLower() const

如果此字节数组是小写，即是其toLower()折叠的等价物，则返回true。

请注意，这并不意味着字节数组只包含小写字母；仅仅是它不包含ASCII大写字母。

另请参阅isUpper()和toLower。

[noexcept] bool QByteArray::isNull() const

如果此字节数组是null，则返回true；否则返回false。

示例

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

Qt出于历史原因区分null字节数组和空字节数组。对于大多数应用程序来说，重要的是一个字节数组是否包含任何数据，这可以使用isEmpty()确定。

另请参阅 isEmpty()。

bool QByteArray::isUpper() const

如果此字节数组是大写，即与它的toUpper()折叠相同，则返回true。

请注意，这并不意味着字节数组只包含大写字母；仅表示它不包含ASCII小写字母。

另请参阅isLower()和toUpper。

[since 6.3] bool QByteArray::isValidUtf8() const

如果此字节数组包含有效的UTF-8编码数据，则返回true，否则返回false。

此函数自Qt 6.3引入。

[since 6.0] qsizetype QByteArray::lastIndexOf(QByteArrayView bv, qsizetype from) const

返回在此字节数组中通过bv查看的最后一个字节序列的起始索引位置，从索引位置from开始搜索。

如果from是-1，则搜索从最后一个字符开始；如果是-2，则从倒数第二个字符开始，以此类推。

如果没有找到匹配项，则返回-1。

示例

QByteArray x("crazy azimuths");
QByteArrayView 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

此函数是在 Qt 6.0 中引入的。

另请参阅 indexOf()，contains() 和 count()。

qsizetype QByteArray::lastIndexOf(char ch, qsizetype from = -1) const

这是一个重载函数。

返回字节数组中字节数据 ch 最后出现的索引位置，搜索方向从索引位置 from 开始。如果 from 为 -1（默认值），则从最后一个字节开始搜索（索引为 size() - 1）。如果没有找到匹配项，则返回 -1。

示例

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

[since 6.2] qsizetype QByteArray::lastIndexOf(QByteArrayView bv) const

这是一个重载函数。

返回从字节数组末尾开始的 bv 视图的字节序列最后一次出现的起始索引位置。如果没有找到匹配项，则返回 -1。

示例

QByteArray x("crazy azimuths");
QByteArrayView 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

此函数是在 Qt 6.2 中引入的。

另请参阅 indexOf()，contains() 和 count()。

QByteArray QByteArray::leftJustified(qsizetype 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()。

[noexcept] qsizetype QByteArray::length() const

与 size() 相同。

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

返回表示整数 n 的文本的字节数组。

返回一个包含表示 n 的字符串的字节数组，使用指定的 base（默认为十进制）。支持的基数从 2 到 36，使用字母表示大于 9 的数字：A 是十，B 是十一，依此类推。

示例

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

另请参阅 setNum() 和 toInt()。

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

这是一个重载函数。

另请参阅toUInt()。

[静态] QByteArray QByteArray::number(long n, int base = 10)

这是一个重载函数。

另请参阅toLong()。

[静态] QByteArray QByteArray::number(ulong n, int base = 10)

这是一个重载函数。

另请参阅toULong()。

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

这是一个重载函数。

另请参阅toLongLong()。

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

这是一个重载函数。

另请参阅toULongLong()。

[静态] QByteArray QByteArray::number(double n, char format = 'g', int precision = 6)

这是一个重载函数。

返回表示浮点数 n 的字节数组文本。

返回包含表示 n 的字符串的字节数组，具有给定的 格式 和 精度，意义与 QString::number(double, char, int) 相同。例如

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

另请参阅toDouble() 和 QLocale::FloatingPointPrecisionOption。

[自 6.4 开始] QByteArray QByteArray::percentDecoded(char percent = '%') const

解码 URI/URL 样式的百分号编码。

返回包含解码文本的字节数组。参数 percent 允许使用不同于 '%' 的字符（例如 '_' 或 '=') 作为转义字符。

例如

QByteArray encoded("Qt%20is%20great%33");
QByteArray decoded = encoded.percentDecoded(); // Set to "Qt is great!"

此函数自 Qt 6.4 开始引入。

另请参阅toPercentEncoding() 和 QUrl::fromPercentEncoding。

QByteArray &QByteArray::prepend(QByteArrayView ba)

将字节数组视图 ba 插入到这个字节数组的前面，并返回对这个字节数组的引用。

此操作通常非常快（恒定时间），因为 QByteArray 在数据开头预留了额外的空间，因此它可以在不重新分配整个数组的情况下增长。

示例

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

这与 insert(0, ba) 相同。

另请参阅 append() 和 insert()。

QByteArray &QByteArray::prepend(char ch)

这是一个重载函数。

将字节 ch 预先附加到这个字节数组。

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

这是一个重载函数。

将字节 ch 的 count 个副本预先附加到这个字节数组。

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

这是一个重载函数。

将以 '\0' 终止的字符串 str 预先附加到这个字节数组。

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

这是一个重载函数。

将 str 开始的 len 个字节预先附加到这个字节数组。附加的字节可能包含 '\0' 字节。

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

这是一个重载函数。

将 ba 预先附加到这个字节数组。

void QByteArray::push_back(const QByteArray &other)

此函数为 STL 兼容性提供。它等效于 append(other)。

void QByteArray::push_back(char ch)

这是一个重载函数。

等同于 append(ch)。

void QByteArray::push_back(const char *str)

这是一个重载函数。

等同于 append(str)。

[since 6.0] void QByteArray::push_back(QByteArrayView str)

这是一个重载函数。

等同于 append(str)。

此函数是在 Qt 6.0 中引入的。

void QByteArray::push_front(const QByteArray &other)

此函数为 STL 兼容性提供。它等效于 prepend(other)。

void QByteArray::push_front(char ch)

这是一个重载函数。

等同于 prepend(ch)。

void QByteArray::push_front(const char *str)

这是一个重载函数。

等同于 prepend(str)。

[since 6.0] void QByteArray::push_front(QByteArrayView str)

这是一个重载函数。

等同于 prepend(str)。

此函数是在 Qt 6.0 中引入的。

QByteArray::reverse_iterator QByteArray::rbegin()

返回一个指向字节数组中第一个字节（反向顺序）的 STL 样式 反向迭代器。

另请参阅 begin()，crbegin() 和 rend()。

[noexcept] QByteArray::const_reverse_iterator QByteArray::rbegin() const

这是一个重载函数。

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

从数组的索引位置 pos 开始，移除 len 个字节，并返回数组的引用。

如果 pos 超出范围，则不会发生任何操作。如果 pos 有效，但 pos + len 大于数组的长度，则数组将在 pos 位置截断。

示例

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

元素移除将会保留数组的容量，不会减少分配的内存额。要在数组的最后更改大小后释放尽可能多的内存，调用 squeeze() 方法。

相关函数insert(), replace(), 以及 squeeze().

[since 6.5] QByteArray &QByteArray::removeAt(qsizetype pos)

移除索引位置 pos 的字符。如果 pos 超出范围（即 pos >= size()），则该函数不执行任何操作。

此函数是在Qt 6.5中引入的。

相关函数remove().

[since 6.5] QByteArray &QByteArray::removeFirst()

从字节数组中移除第一个字符。如果字节数组为空，该函数不执行任何操作。

此函数是在Qt 6.5中引入的。

相关函数remove().

[since 6.1] template <typename Predicate> QByteArray &QByteArray::removeIf(Predicate pred)

从字节数组中移除所有使谓词 pred 返回 true 的字节。返回字节数组的引用。

此函数是在Qt 6.1中引入的。

相关函数remove().

[since 6.5] QByteArray &QByteArray::removeLast()

从字节数组中移除最后一个字符。如果字节数组为空，该函数不执行任何操作。

此函数是在Qt 6.5中引入的。

相关函数remove().

QByteArray::reverse_iterator QByteArray::rend()

返回一个 STL-style 逆序迭代器，指向字节数组的最后一个字节之后，按逆序排列。

相关函数end(), crendrbegin().

[noexcept] QByteArray::const_reverse_iterator QByteArray::rend() const

这是一个重载函数。

QByteArray QByteArray::repeated(qsizetype times) const

返回当前字节数组重复指定次数的副本。

如果 times 小于 1，则返回一个空字节数组。

示例

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

QByteArray &QByteArray::replace(qsizetype pos, qsizetype len, QByteArrayView after)

用字节数组 after 中的字节替换从索引位置 pos 开始的 len 个字节，并返回对当前字节数组的引用。

示例

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

另请参阅insert()和remove()。

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

这是一个重载函数。

从索引位置pos开始用alen字节数据替换len字节。插入的数据可能包括'\0'字节。

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

这是一个重载函数。

将每个出现的字节before替换为字节序列after。

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

这是一个重载函数。

将起始于before的bsize字节每个都替换为起始于after的asize字节。由于字符串大小由bsize和asize指定，因此它们可能包含'\0'字节，并且不需要'\0'终止。

[自6.0起] QByteArray &QByteArray::replace(QByteArrayView before, QByteArrayView after)

这是一个重载函数。

将每个出现的字节序列before替换为字节序列after。

示例

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

此函数是在 Qt 6.0 中引入的。

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

这是一个重载函数。

将每个出现的字节before替换为字节after。

void QByteArray::reserve(qsizetype size)

尝试分配至少size字节的内存。

如果你事先知道字节数组的大小，可以调用此函数，并且如果你经常调用resize()，你很可能会获得更好的性能。

如果你不确定需要多少空间，通常最好使用一个上限作为size，或者是对最可能的大小的一个高估值，如果严格的上限会远大于这个值。如果size是一个低估，当预留的大于所需大小时，数组将根据需要进行扩展，这可能导致比最佳高估更大的分配，并且会减慢触发它的操作。

此函数的唯一目的是为了提供一种微调QByteArray内存使用的方法。通常，你很少需要调用此函数。

另请参阅squeeze()和capacity()。

void QByteArray::resize(qsizetype size)

将字节数组的大小设置为size字节。

如果大小大于当前大小，字节数组将扩展以使其达到大小字节，额外的字节将添加到末尾。新的字节未初始化。

如果大小小于当前大小，则从字节数组中排除大小位置之外的字节。

另请参阅 size()，truncate()和squeeze。

[自6.4起] void QByteArray::resize(qsizetype newSize, char c)

将字节数组的大小设置为newSize字节。

如果newSize大于当前大小，则字节数组将扩展以使其达到newSize字节，额外的字节将添加到末尾。新的字节初始化为c。

如果newSize小于当前大小，则从字节数组中排除newSize位置之外的字节。

此函数自 Qt 6.4 开始引入。

另请参阅 size()，truncate()和squeeze。

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

返回一个包含fill字节和此字节数组的字节数组，长度为width。

如果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表示为文本。

将此字节数组设置为表示n的字符串，基数base（默认为十），并返回对此字节数组的引用。支持2到36的基数，使用字母表示超出9的数字；A表示十，B表示十一，依此类推。

示例

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

另请参阅 number()和toInt()。

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

这是一个重载函数。

另请参阅 toShort。

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

这是一个重载函数。

另请参阅 toUShort。

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

这是一个重载函数。

另请参阅toUInt()。

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

这是一个重载函数。

另请参阅toLong()。

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

这是一个重载函数。

另请参阅toULong()。

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

这是一个重载函数。

另请参阅toLongLong()。

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

这是一个重载函数。

另请参阅toULongLong()。

QByteArray &QByteArray::setNum(float n, char format = 'g', int precision = 6)

这是一个重载函数。

将浮点数n表示为文本。

将此字节数组设置为表示n的字符串，并指定了format和precision（与QString::number(double, char, int))的含义相同），并返回对此字节数组的引用。

另请参阅toFloat()。

QByteArray &QByteArray::setNum(double n, char format = 'g', int precision = 6)

这是一个重载函数。

将浮点数n表示为文本。

将此字节数组设置为表示n的字符串，并指定了format和precision（与QString::number(double, char, int))的含义相同），并返回对此字节数组的引用。

另请参阅toDouble() 和 QLocale::FloatingPointPrecisionOption。

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

将QByteArray重置为使用data数组的前size个字节。字节不会复制。QByteArray将包含data指针。调用者保证只要此QByteArray及其任何未修改的副本存在，data就不会被删除或修改。

此函数可以用作替代fromRawData()，以重用现有的QByteArray对象以节省内存重新分配。

另请参阅fromRawData()，data()和constData()。

void QByteArray::shrink_to_fit()

此函数提供以兼容STL。它与squeeze()等效。

QByteArray QByteArray::simplified() const

返回一个副本字节数组，移除开始和结束的空格字符以及将内部空格字符序列替换为单个空格。

空格字符是使标准C++ isspace() 函数返回true的ASCII字符；这些是制表符 '\t'，换行 '\n'，回车 '\r'，垂直制表符 '\v'，换页符 '\f'和空格 ' '。

示例

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

另请参阅trimmed()，QChar::SpecialCharacter和Spacing Characters。

[noexcept] qsizetype QByteArray::size() const

返回此字节数组中的字节数。

字节数组的最后一个字节位于位置 size() - 1。此外，QByteArray 确保位置 size() 的字节始终是 '\0'，这样您就可以将 data() 和 constData() 的返回值作为需要 '\0' 结尾的字符串的函数参数。如果 QByteArray 对象是从不包含尾随 '\0' 结尾字节的 原始数据 创建的，那么 QByteArray 不会自动添加它，除非创建了一个 深拷贝。

示例

QByteArray ba("Hello");
qsizetype 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()。

[since 6.0] bool QByteArray::startsWith(QByteArrayView bv) const

如果此字节数组以 bv 观察的字节序列开头，则返回 true；否则返回 false。

示例

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

此函数是在 Qt 6.0 中引入的。

另请参阅 endsWith() 和 first()。

bool QByteArray::startsWith(char ch) const

这是一个重载函数。

如果此字节数组以字节 ch 开头，则返回 true；否则返回 false。

[noexcept] void QByteArray::swap(QByteArray &other)

交换字节数组 other 与此字节数组。此操作非常快且从不失败。

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

返回一个已使用 options 选项编码的字节数组的副本。

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

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 中定义。

另请参阅 fromBase64()。

CFDataRef QByteArray::toCFData() const

从 QByteArray 创建一个 CFData。

调用者拥有 CFData 对象，并负责释放它。

另请参阅 toRawCFData()，fromCFData()，fromRawCFData() 和 fromRawData()。

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

返回将字节数组转换为 double 值。

如果转换溢出，则返回无穷大；如果因其他原因（例如下溢）转换失败，则返回0.0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

QByteArray string("1234.56");
bool ok;
double a = string.toDouble(&ok);   // a == 1234.56, ok == true

string = "1234.56 Volt";
a = str.toDouble(&ok);             // a == 0, ok == false

此函数忽略前导和尾随空白。

另请参阅number()。

[since 6.5] emscripten::val QByteArray::toEcmaUint8Array()

从QByteArray创建一个Uint8Array。

此函数将来自QByteArray的堆内存数据传输到JavaScript数据缓冲区。函数分配一个ArrayBuffer并将其复制进去，然后返回一个指向该缓冲区的Uint8Array视图。

JavaScript对象拥有数据的副本，此QByteArray可以在副本制作后被安全删除。

QByteArray byteArray = "test";
emscripten::val uint8array = QByteArray::toEcmaUint8Array(byteArray);

此函数是在Qt 6.5中引入的。

另请参阅toEcmaUint8Array()。

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

返回转换为float值的字节数组。

如果转换溢出，则返回无穷大；如果因其他原因（例如下溢）转换失败，则返回0.0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

QByteArray string("1234.56");
bool ok;
float a = string.toFloat(&ok);    // a == 1234.56, ok == true

string = "1234.56 Volt";
a = str.toFloat(&ok);              // a == 0, ok == false

此函数忽略前导和尾随空白。

另请参阅number()。

QByteArray QByteArray::toHex(char separator = '\0') 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"

另请参阅fromHex()。

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

使用基数base将字节数组转换为int，默认为十进制。支持0和2至36的基数，使用字母表示超过9的数字；A为10，B为11，以此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回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

另请参阅number()。

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

使用基数base将字节数组转换为long int，默认为十进制。支持0和2至36的基数，使用字母表示超过9的数字；A为10，B为11，以此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回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

另请参阅number()。

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

使用默认为十进制的基础base将字节数组转换为长整型字节数组。支持的进制为0和2至36，使用字母表示9以上的数字；A代表十，B代表十一，依此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

另请参阅number()。

QByteArray QByteArray::toLower() const

返回字节数组的副本，其中每个ASCII大写字母转换为小写。

示例

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

另请参阅isLower()，toUpper()和Character Case。

NSData *QByteArray::toNSData() const

从QByteArray创建NSData。

NSData对象是自动释放的。

另请参阅fromNSData()，fromRawNSData()，fromRawData()和toRawNSData。

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

返回URI/URL风格的百分比编码的字节数组副本。当您想使用其他字符而不是默认的'%'字符时，可以使用percent参数来覆盖。

默认情况下，此函数会编码所有不属于以下字符的bytes

ALPHA ("a"到"z"和"A"到"Z") / DIGIT (0到9) / "-" / "." / "_" / "~"）

要将bytes编码，请将其传递给include以阻止bytes编码，请将它们传递给exclude。百分号始终编码。

示例

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

十六进制编码使用数字0-9和大写字母A-F。

另请参阅fromPercentEncoding()和QUrl::toPercentEncoding。

CFDataRef QByteArray::toRawCFData() const

使用QByteArray的bytes构建CFData。

不会复制QByteArray的bytes。

调用者保证在CFData对象存在期间，QByteArray不会被删除或修改。

另请参阅toCFData()，fromRawCFData()，fromCFData()和fromRawData。

NSData *QByteArray::toRawNSData() const

使用QByteArray的bytes构建NSData。

不会复制QByteArray的bytes。

调用者保证，在NSData对象存在期间，将不会删除或修改QByteArray。

另请参阅fromRawNSData()，fromNSData()，fromRawData()和toNSData。

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

返回使用基础base转换为的字节码数组，默认为十进制。支持0和2至36进制，使用字母表示大于9的数字；A代表十，B代表十一，以此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

另请参阅number()。

std::string QByteArray::toStdString() const

返回包含在此QByteArray中的数据的std::string对象。

此运算符主要用于将QByteArray传递给接受std::string对象的函数。

另请参阅fromStdString()和QString::toStdString。

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

返回使用基础base转换为的字节码数组的无符号整数，默认为十进制。支持0和2至36进制，使用字母表示大于9的数字；A代表十，B代表十一，以此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

另请参阅number()。

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

返回使用基础base转换为的字节码数组的无符号长整数的无符号长整数，默认为十进制。支持0和2至36进制，使用字母表示大于9的数字；A代表十，B代表十一，以此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

另请参阅number()。

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

返回使用基础base转换为的字节码数组的无符号长长整数的无符号长长整数，默认为十进制。支持0和2至36进制，使用字母表示大于9的数字；A代表十，B代表十一，以此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

另请参阅number()。

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

返回使用基础base转换为的字节码数组的无符号短整数的无符号短整数，默认为十进制。支持0和2至36进制，使用字母表示大于9的数字；A代表十，B代表十一，以此类推。

如果base是0，则根据以下规则自动确定基数：如果字节数组以"0x"开头，则假定它是十六进制（基数16）；否则，如果以"0b"开头，则假定它是二进制（基数2）；否则，如果以"0"开头，则假定它是八进制（基数8）；否则假定它是十进制。

如果转换失败，则返回0。

如果 ok 不是 nullptr，则通过将 *ok 设置为 false 来报告失败，并通过将 *ok 设置为 true 来报告成功。

另请参阅number()。

QByteArray QByteArray::toUpper() const

返回一个副本字节码数组，其中每个ASCII小写字母都转换为大写字母。

示例

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

另请参阅isUpper()，toLower()和字符大小写。

QByteArray QByteArray::trimmed() const

返回一个副本字节码数组，从开始和结束处删除空格字符。

空格字符是使标准C++ isspace() 函数返回true的ASCII字符；这些是制表符 '\t'，换行 '\n'，回车 '\r'，垂直制表符 '\v'，换页符 '\f'和空格 ' '。

示例

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

与简化不同，trimmed()保留内部空格不变。

另请参阅简化，QChar::SpecialCharacter和空格字符。

void QByteArray::truncate(qsizetype pos)

在指定位置索引截断字节数组。

如果 pos 超出了数组的末尾，则不执行任何操作。

示例

QByteArray ba("Stockholm");
ba.truncate(5);             // ba == "Stock"

参见chop()，resize() 和 first()。

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

如果此字节数组不等于 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较区分大小写。

您可以通过在编译应用程序时定义 QT_NO_CAST_FROM_ASCII 来禁用此操作符。然后，如果您想在比较之前将字节数组转换为 QString，则需要显式调用 QString::fromUtf8，QString::fromLatin1 或 QString::fromLocal8Bit()。

QByteArray &QByteArray::operator+=(const QByteArray &ba)

将字节数组 ba 添加到该字节数组的末尾，并返回对该字节数组的引用。

示例

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

注意：QByteArray 是一个 隐式共享 的类。因此，如果是向一个空的字节数组追加内容，该字节数组将仅共享 ba 中的数据。在这种情况下，不执行数据复制，耗时 恒定时间。如果共享实例被修改，它将被复制（写时复制），耗时 线性时间。

如果追加的字节数组不为空，则会执行数据的深复制，耗时 线性时间。

此操作通常不会遭受分配开销，因为 QByteArray 在数据末尾预分配额外的空间，以便在每次附加操作时不重新分配即可增长。

参见append() 和 prepend()。

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

这是一个重载函数。

将字节数组 ch 添加到该字节数组的末尾，并返回对该字节数组的引用。

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

这是一个重载函数。

将以 '\0' 结尾的字符串 str 添加到该字节数组的末尾，并返回对该字节数组的引用。

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

如果此字节数组在字典序上小于 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较区分大小写。

您可以通过在编译应用程序时定义 QT_NO_CAST_FROM_ASCII 来禁用此操作符。然后，如果您想在比较之前将字节数组转换为 QString，则需要显式调用 QString::fromUtf8，QString::fromLatin1 或 QString::fromLocal8Bit()。

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

如果此字节数组在字典序上小于或等于 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较区分大小写。

您可以通过在编译应用程序时定义 QT_NO_CAST_FROM_ASCII 来禁用此操作符。然后，如果您想在比较之前将字节数组转换为 QString，则需要显式调用 QString::fromUtf8，QString::fromLatin1 或 QString::fromLocal8Bit()。

[noexcept] QByteArray &QByteArray::operator=(const QByteArray &other)

将 other 分配给该字节数组，并返回对该字节数组的引用。

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

这是一个重载函数。

将 str 分配给该字节数组。

str 假设指向一个空终止的字符串，其长度是动态确定的。

[noexcept] QByteArray &QByteArray::operator=(QByteArray &&other)

将 other 移动分配给此 QByteArray 实例。

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

如果此字节数组等于 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较区分大小写。

您可以通过在编译应用程序时定义 QT_NO_CAST_FROM_ASCII 来禁用此操作符。然后，如果您想在比较之前将字节数组转换为 QString，则需要显式调用 QString::fromUtf8，QString::fromLatin1 或 QString::fromLocal8Bit()。

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

如果此字节数组在词法上大于 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较区分大小写。

您可以通过在编译应用程序时定义 QT_NO_CAST_FROM_ASCII 来禁用此操作符。然后，如果您想在比较之前将字节数组转换为 QString，则需要显式调用 QString::fromUtf8，QString::fromLatin1 或 QString::fromLocal8Bit()。

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

如果此字节数组大于或等于 str 的 UTF-8 编码，则返回 true；否则返回 false。

比较区分大小写。

您可以通过在编译应用程序时定义 QT_NO_CAST_FROM_ASCII 来禁用此操作符。然后，如果您想在比较之前将字节数组转换为 QString，则需要显式调用 QString::fromUtf8，QString::fromLatin1 或 QString::fromLocal8Bit()。

char &QByteArray::operator[](qsizetype i)

返回位于索引位置 i 的字节的可修改引用。

i必须是字节数组中的有效索引位置（即，0 <= i < size()).

示例

QByteArray ba("Hello, world");
cout << ba[0]; // prints H
ba[7] = 'W';
// ba == "Hello, World"

另请参阅at().

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

这是一个重载函数。

与 at(i) 相同。