qt中QByteArray字节数组

QByteArray bb("Hello");  //创建字节数组
    int n=bb.size(); //返回字节数组的大小
    //不包括终止符 
    QByteArray ba;//创建一个空字节数组
    ba.resize(6);//设置字节数组的大小
    //    为终止符
    ba[0] = 0x3c;  //赋值
    ba[1] = 0xb8;
    ba[2] = 0x64;
    ba[3] = 0x18;
    ba[4] = 0xca;

    char* p;

    p=ba.data();  //返回字节数组的指针--char*
    p[5]= 0x31;  //给第5个字节赋值

    char z;
    char z1;
    char z2;
    char z3;
    z=p[2];   //返回第2个字节
    z1=ba[2]; //返回第2个字节
    z2=ba.at(2); //返回第2个字节
    z3=ba.constData()[2];//返回第2个字节

QByteArray ba = QByteArray::fromHex("4142434445"); //把Hex编码转换为char存储到QByteArray
    //参数 16进制的数据  两位一个字节
    QString s=ba.toHex();  //把QByteArray转为Hex编码
    //"4142434445"

    int n = 63;
    s=QByteArray::number(n);  //把数值转换成字符串
    //"63"
    s=QByteArray::number(n,16);
    //参数1：可以是任何类型的数值
    //参数2  进制  默认10进制   取值：可以是2到36之间的任何值
    //"3f"
    s=QByteArray::number(63.89);
    //"63.89"

    ba.setNum(n); //按照指定进制格式直接复制，其中n可以是各类常见数值类型
    //"63"
    ba.setNum(63.7);
    //"63.7"
    ba.setNum(n,16);
    //参数2：进制
    //"3f"

    QByteArray ba1 = QByteArray::number(12.3456, 'G', 3);//把数值按指定格式和小数位转换输出，小数位四舍五入
    /*参数2：指定格式
            E  科学计数法格式    "1.235E+01"
            e  科学计数法格式    "1.235e+01"
            f  浮点数           "12.346"
            g  使用e或f格式，以最简洁的为准    "12.3"
            G  使用E或f格式，以最简洁的为准    "12.3"
    参数3：小数位数  */

    QByteArray ba2=("414243");
    //"414243"

    n=ba2.toInt();  //转换成int
    //414243
    //如果转换失败，则返回0

    bool b;
    n=ba2.toInt(&b,16);
    //4276803
    //参数1：转换失败返回false，转换成功返回true
    //参数2：ba2中数据的进制

    QByteArray ba3("1234.56");
    n=ba3.toInt();  //返回0, 小数均视为0
    n=ba3.toInt(&b,16);  //返回0, 小数均视为0
    float f=ba3.toFloat();  //转换成浮点数
    //1234.56
    double d=ba3.toDouble();  //转换成double
    //1234.56

    //QByteArray若为带大小写的字符串，可通过toUpper()和toLower()方法实现大小写转换
    QByteArray ba4("Qt by THE QT COMPANY");
    QByteArray ba5 = ba4.toLower();//转换成小写
    //"qt by the qt company"

    QByteArray ba6 = ba4.toUpper();//转换成大写
    //"QT BY THE QT COMPANY"

    //QByteArray与QString互转极为简单，二者从本质上类似，都是连续存储，区别是前者可以存无法显示的字符，后者只存可显示的字符
    QByteArray ba7("abc123");
    QString str = ba7; //转换成QString--方法一
    //"abc123"
    QString str1;
    str1.prepend(ba7);// QByteArray转QString方法2
    //"abc123"

    QString str2("hello");
    QByteArray ba8 = str2.toUtf8(); // QString转QByteArray方法1
    //"hello"

    QByteArray ba9 = str2.toLatin1();  // QString转QByteArray方法2
    //"hello"

    QByteArray ba10("Istambul");
    ba10.fill('X', 2); // 用指定的字符填充
    //参数1：填充的字符
    //参数2：填充后的大小；默认值：-1,全部填充
    //"XX"

    QByteArray ba11("lmsticky question");
    QByteArray ba12("sti");
    n=ba11.indexOf(ba12,1);//返回ba11字节数组中第一次出现字节数组ba12的索引位置，从索引位置向前搜索。如果找不到ba12，则返回-1
    //2
    //参数2：开始搜索的位置

    n=ba11.indexOf('t',1);  //返回ba11字节数组中第一次出现char字符的索引位置，从索引位置向前搜索。如果找不到，则返回-1
    //3

    n=ba11.indexOf("st",1);  //搜索字符串

QByteArray ba = QByteArray("");
    bool b=ba.isEmpty();//是否空字符；如果字节数组的大小为0，返回true; 否则返回false
    //true
    bool b1=ba.isNull();  //是否为空
    //false

    QByteArray ba1 = QByteArray("414243");
    QByteArray ba2=ba1.left(4);  //返回一个字节数组，该数组包含该字节数组最左边的n个字节。
    //如果n大于size（），则返回整个字节数组

    QByteArray ba3 = QByteArray("liming");
    QByteArray ba4=ba3.leftJustified(9,'.'); //返回一个指定大小的字节数组
    //"liming..."
    //参数1：字节数组的大小
    //参数2：填充字符--当指定的大小比原来的大时，用来填充
    QByteArray ba5=ba3.leftJustified(3,'.');
    //"liming"
    QByteArray ba6=ba3.leftJustified(3,'.',true);
    //参数3：默认为false:当参数1小于原大小时，返回原来的；   为true:当参数1小于原大小时，返回指定大小
    //"lim"

    int n=ba3.length(); //与size相同，返回大小

    QByteArray ba7=ba3.mid(1,3); //截取
    /*
参数1：开始截取的位置
参数2：截取的长度；如果省略一直到末尾
*/

    QByteArray x=QByteArray("88");
QByteArray ba8=ba3.insert(2,x);  //插入QByteArray
//"li88ming"
//参数1：插入的位置
//注意：ba3也改变了

QByteArray ba10=QByteArray("liming");
QByteArray ba11=ba10.insert(2,'x'); //插入一个字符
//注意：ba10也改变了

QByteArray ba12=QByteArray("liming");
QByteArray ba13=ba12.insert(2,3,'x');  //插入n个字符
//参数1：插入的位置
//参数2：插入的个数
//注意：ba12也改变了

QByteArray ba14=QByteArray("liming");
QByteArray ba15=ba14.insert(2,"LG"); //插入一个字符串
//注意：ba14也改变了

QByteArray ba16=QByteArray("liming");
QByteArray ba17=ba16.insert(2,"LGHKD",3); //插入一个指定长度的字符串
//注意：ba16也改变了
//参数3：插入参数2中前n个字符；如果参数2不够长用填补

QByteArray ba18=QByteArray("liming");
QByteArray ba19=QByteArray("ng");
b=ba18.endsWith(ba19); //如果b18字节数组以字节数组ba19结尾，则返回true；否则返回false
b=ba18.endsWith('n');//如果b18字节数组以指定字节结尾，则返回true；否则返回false
b=ba18.endsWith("ing");//如果b18字节数组以指定字节串结尾，则返回true；否则返回false

char c=ba18.front();  //返回第一个字符

    QByteArray ba = QByteArray("liming");
    QByteArray ba1=QByteArray("ABC");
    QByteArray ba2=ba.append(ba1); //尾部追加
    //"limingABC"
    //注意：ba也修改了

    ba = QByteArray("liming");
    ba2=ba.append('K'); //尾部追加
    //注意：ba也修改了

    ba = QByteArray("liming");
    ba2=ba.append("GDL"); //尾部追加
    //注意：ba也修改了

    ba = QByteArray("liming");
    ba2=ba.append("GDL",6); //尾部追加
    //注意：ba也修改了
    //参数2：追加参数1中前n个字节;如果参数1不够大，会自动填补
    //"limingGDLx00.."

    ba = QByteArray("liming");
    char c=ba.back(); //返回字节数组中的最后一个字符

    int n=ba.capacity();  //可以存储在字节数组中的最大字节数
    int nn=ba.size();

    ba.chop(2);//从字节数组的末尾删除n个字节
    //"limi"

    ba = QByteArray("liming");
    ba2=ba.chopped(2);//从字节数组的末尾删除n个字节
    //ba不改变

    ba2.clear();//清空

    ba1=QByteArray("Liming");
    n=ba.compare(ba1,Qt::CaseInsensitive); //比较
    /*
返回值：
    如果  ba>ba1   大于0
    如果  ba=ba1   等于0
    如果  ba 
  
QByteArray ba = QByteArray("ABmi  KG liming");
QByteArray ba1 = QByteArray("mi");

int n=ba.lastIndexOf(ba1);//在ba中从后往前搜索ba1,返回找到的索引号
//如果找不到ba1，则返回-1

n=ba.lastIndexOf(ba1,6);//在ba中从后往前搜索ba1,返回找到的索引号
//如果找不到ba1，则返回-1
//参数2：开始搜索的位置；默认-1，表示末尾开始


n=ba.lastIndexOf('B',6);//在ba中从后往前搜索指定字符,返回找到的索引号
//如果找不到ba1，则返回-1
//参数2：开始搜索的位置；默认-1，表示末尾开始

n=ba.lastIndexOf("Bm",6);//在ba中从后往前搜索指定字符串,返回找到的索引号
//如果找不到ba1，则返回-1
//参数2：开始搜索的位置；默认-1，表示末尾开始


ba = QByteArray("liming");
ba1 = QByteArray("AB");
QByteArray ba2=ba.prepend(ba1); //在ba的前面追加ba1
//注意：ba  ba2 都改变了
//"ABliming"

ba = QByteArray("liming");
ba2=ba.prepend('K'); //在ba的前面追加字符
//注意：ba  ba2 都改变了

ba = QByteArray("liming");
ba2=ba.prepend("KG"); //在ba的前面追加字符串
//注意：ba  ba2 都改变了

ba = QByteArray("liming");
ba2=ba.prepend("KGABC",2); //在ba的前面追加字符串
//注意：ba  ba2 都改变了
//参数2:追加的字节数
 
  
    QByteArray ba = QByteArray("liming");
    QByteArray ba1 = QByteArray("AB");
    ba.push_back(ba1); //尾部追加

    ba = QByteArray("liming");
    ba.push_back("ABC"); //尾部追加

    ba = QByteArray("liming");
    ba.push_back('Q'); //尾部追加


    ba = QByteArray("liming");
    ba.push_front('Q'); //前面追加

    ba = QByteArray("liming");
    ba.push_front("AB"); //前面追加

    ba = QByteArray("liming");
    ba.push_front(ba1); //前面追加

    ba = QByteArray("liming");
    QByteArray ba3=ba.remove(1,2);  //移除
    //从数组中移除len字节，从索引位置pos开始，并返回对数组的引用。如果pos超出范围，则不会发生任何事情。如果pos有效，但pos+len大于数组的大小，则在pos处截断数组
    //注意：ba ba3都改变了
    //参数1:pos  移除的起始位置
    //参数2:len 移除的字节数

    ba = QByteArray("liming");

    ba3=ba.repeated(2); //返回重复指定次数的字节数组
    //如果参数小于1，则返回空字节数组
    //"limingliming"

    ba3=ba.replace(2,4,ba1); //替换
    //注意：ba ba3都改变了
    //参数1：起始位置
    //参数2：替换的字节数
    //参数3：替换的内容

    ba = QByteArray("liming");
    ba3=ba.replace(2,4,"KG"); //替换
    //注意：ba ba3都改变了
    //参数1：起始位置
    //参数2：替换的字节数
    //参数3：替换的内容

    ba = QByteArray("liming");
    ba3=ba.replace(2,4,"KGABC",2); //替换
    //注意：ba ba3都改变了
    //参数1：起始位置
    //参数2：替换的字节数
    //参数3：替换的内容
    //参数4：从参数3中取出指定字节数去替换

    ba = QByteArray("liming");
    ba3=ba.replace('i',"LM"); //替换--将前面出现的每个字符替换为后面的字符串
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符
    //参数2：用来替换的字符串

    ba = QByteArray("liming");
    ba3=ba.replace('i',ba1); //替换--将前面出现的每个字符替换为后面的字节数组
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符
    //参数2：用来替换的字节数组

    ba = QByteArray("liming");
    ba3=ba.replace("ming","xueqian"); //替换--将前面出现的字符串换为后面的字节串
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符串
    //参数2：用来替换的字节串

    ba = QByteArray("liming");
    ba3=ba.replace("ming",4,"xueqian",3); //替换--将前面出现的字符串换为后面的字节串
    //注意：ba ba3都改变了
    //参数1：要被替换掉的字符串
    //参数2：要被替换掉的字节数
    //参数3：用来替换的字符串
    //参数4：用来替换的字节数
    //"lixue"

    ba = QByteArray("liming");
    ba1 = QByteArray("ming");
    QByteArray ba2 = QByteArray("xueqian");

    ba3=ba.replace(ba1,ba2); //替换--将前面字节数组的内容换为后面字节数组的内容
    //注意：ba ba3都改变了
    //"lixueqian"

    ba = QByteArray("liming");
    ba3=ba.replace(ba1,"xue"); //替换--将前面字节数组的内容替换为后面的字符串
    //注意：ba ba3都改变了
    //"lixue"

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


    ba = QByteArray("liming");
    ba3=ba.right(4);//返回一个字节数组，该数组包含该字节数组最右边的len字节。如果len大于size（），则返回整个字节数组

    ba3=ba.rightJustified(4,'.',false);//返回一个字节数组，该数组包含该字节数组最右边的最多len字节
   /*
参数1：len  当len大于ba原大小时，返回len字节数组，左边用参数2填充   "...liming"
参数3：true时：当len小于原大小时，返回左边的len字节数(4)  "limi"
    false时(默认)：当len小于原大小时，返回ba的原内容
    */

    ba = QByteArray("
   li
ming 	  ");
    ba3=ba.simplified();//删除两头空白字符，内部的空白字符用空格替换
    //"li ming"
    //C标准中空白字符有：空格（‘ ’）、换页（‘f’）、换行（‘
’）、回车（‘
’）、水平制表符（‘	’）、垂直制表符（‘v’）六个

    ba = QByteArray("liming|lixueqian|lixiuyan");
    QList lb=ba.split('|');  //分割
    //参数：分割字符
    //("liming", "lixueqian", "lixiuyan")

    ba = QByteArray("liming");
    ba1=QByteArray("li");
    bool b=ba.startsWith(ba1);//如果ba字节数组以字节数组ba1开头，则返回true；否则返回false
    b=ba.startsWith('l');//如果ba字节数组以指定字符开头，则返回true；否则返回false
    b=ba.startsWith("li");//如果ba字节数组以指定字符串开头，则返回true；否则返回false

    ba.swap(ba1); //交换

    ba = QByteArray("	   li
ming    
");
    ba1=ba.trimmed();//删除两头的空白字符
    //"li
ming"

    ba = QByteArray("liming");
    ba.truncate(2);//截取前n字节
    //"li"

    ba = QByteArray("liming");
    ba1 = QByteArray("AB");
    ba+=ba1;  //ba的尾部追加ba1
    //"limingAB"

    ba+='C'; //ba的尾部追加字符
    //"limingABC"

    ba+="DE"; //ba的尾部追加字符串
    //"limingABCDE"

    b=ba<"Li";  //可以 逻辑比较
 
  
/***********************************************
 
  
一、描述
 QByteArray 是字节数组，可用于存储原始字节（包括 '\0'）和传统的 8 位以 '\0' 结尾的字符串。使用 QByteArray 比使用 const char * 方便得多。在幕后，它始终确保数据后跟一个“\0”终止符，并使用隐式共享（copy-on-write）来减少内存使用并避免不必要的数据复制。
 
  
除了 QByteArray，Qt 还提供了 QString 类来存储字符串数据。对于大多数用途，QString 是理想的字符串类。它将其内容理解为 Unicode 文本（使用 UTF-16 编码），QString 在 Qt API 中贯穿始终。QByteArray 没有经过编码，储存的是原始的数据。
 
  
QByteArray 适用的两种主要情况：
 
  
当需要存储原始二进制数据时
 当内存资源很宝贵时
 1.1、初始化介绍
 初始化 QByteArray 的一种方法是简单地将 const char * 传递给其构造函数：
 
  
QByteArray ba("Hello");
 尽管 size() 为 5，但字节数组在末尾还保留了一个额外的 '\0' 字节，因此如果请求指向底层数据的指针（例如调用 data()），则指向的数据保证以 '\0' 结尾。
 
  
QByteArray 对 const char * 数据进行了深拷贝。如果出于性能原因不想对数据进行深拷贝，请改用 QByteArray::fromRawData()。
 
  
另一种初始化方法是使用 resize() 设置数组的大小并逐字节初始化数据。
 
  
1.2、访问元素
 QByteArray 使用基于 0 的索引，就像 C++ 数组一样。要访问特定索引位置的字节，可以使用 operator[]()。在非常量字节数组上，operator[]() 返回对可在赋值左侧使用的字节的引用。例如：
 
  
QByteArray ba;
 ba.resize(5);
 ba[0] = 0x3c;
 ba[1] = 0xb8;
 ba[2] = 0x64;
 ba[3] = 0x18;
 ba[4] = 0xca;
 对于只读访问，另一种语法是使用 at()：
 
  
for (qsizetype i = 0; i < ba.size(); ++i) 
 {
     if (ba.at(i) >= 'a' && ba.at(i) <= 'f')
         cout << "在范围内找到字符 [a-f]" << Qt::endl;
 }
 at() 可以比 operator[]() 更快，因为它不会深拷贝。
 
  
QByteArray 可以嵌入 '\0' 字节。size() 函数总是返回整个数组的大小，包括嵌入的 '\0' 字节，但不包括 QByteArray 添加的终止 '\0'。
 
  
1.3、迭代器
 QByteArray 提供 STL 风格的迭代器（QByteArray::const_iterator 和 QByteArray::iterator）。在实践中，迭代器在使用 C++ 标准库提供的通用算法时很方便。
 
  
迭代器和对单个 QByteArray 元素的引用受稳定性问题的影响。当调用 QByteArray 修改操作（例如 insert() 或 remove()）时，它们通常会失效。当需要稳定性和类似迭代器的功能时，应该使用索引而不是迭代器，因为它们与 QByteArray 的内部状态无关，因此不会失效。
 
  
1.4、内存分配
 当数据修改函数增加数组的大小时，它们可能会导致 QByteArray 对象的内存重新分配。发生这种情况时，QByteArray 会扩展比它立即需要的更多，以便在不重新分配的情况下有进一步扩展的空间。
 
  
如果正在逐步构建一个 QByteArray 并且预先知道 QByteArray 大约包含多少字节，则可以调用reserve()，要求 QByteArray 预先分配一定数量的内存。还可以调用 capacity() 来查看 QByteArray 实际分配了多少内存。
 
  
由于隐式共享，使用非常量运算符和函数可能会导致 QByteArray 对数据进行深拷贝。
 
  
1.5、判空
 null byte array是使用 QByteArray 的默认构造函数或通过将 (const char *)0 传递给构造函数来初始化的字节数组。empty byte array是大小为 0 的字节数组：
 
  
 QByteArray().isNull();          // returns true
  QByteArray().isEmpty();         // returns true
  
  QByteArray("").isNull();        // returns false
  QByteArray("").isEmpty();       // returns true
  
  QByteArray("abc").isNull();     // returns false
  QByteArray("abc").isEmpty();    // returns false
 建议始终使用 isEmpty() 并避免使用 isNull()。
 
  
1.6、内存不足情况
 当内存分配失败时，如果应用程序编译时支持异常，则 QByteArray 会抛出 std::bad_alloc 异常。
 
  
Qt 容器中的内存不足情况是 Qt 会抛出异常的唯一情况。如果异常被禁用，则内存不足是未定义的行为。
 
  
二、类型成员
 1、enum QByteArray::Base64Option：此枚举包含可用于编码和解码 Base64 的选项。
 
  
Base64Encoding：常规 Base64 字母表，简称为“base64”
 Base64UrlEncoding：替代字母表，称为“base64url”，它替换字母表中的两个字符以对 URL 更友好。
 KeepTrailingEquals：在编码数据的末尾保留尾随填充等号，因此数据的大小始终是 4 的倍数。
 OmitTrailingEquals：省略在编码数据的末尾添加填充等号。
 IgnoreBase64DecodingErrors：解码 Base64 编码数据时，忽略输入中的错误。无效字符被简单地跳过。
 AbortOnBase64DecodingErrors：解码 Base64 编码数据时，在第一个解码错误处停止。
 fromBase64Encoding() 和 fromBase64() 忽略 KeepTrailingEquals 和 OmitTrailingEquals 选项。
 
  
2、迭代器
 
  
QByteArray::const_iterator：const迭代器。
 QByteArray::const_reverse_iterator：const反向迭代器。
 QByteArray::iterator
 QByteArray::reverse_iterator
 三、成员函数
  1、【static】QByteArray::FromBase64Result fromBase64Encoding(QByteArray &&base64, QByteArray::Base64Options options = Base64Encoding)
 
  
       【static】QByteArray::FromBase64Result fromBase64Encoding(const QByteArray &base64, QByteArray::Base64Options options = Base64Encoding)
 
  
使用 options 定义的选项解码 Base64 数组 base64。
 
  
返回一个 QByteArrayFromBase64Result 对象，包含解码后的数据和一个指示解码是否成功的标志。
 
  
    QByteArray text("http://www.baidu.com");
     qDebug()<< text.toBase64(QByteArray::Base64Encoding);//aHR0cDovL3d3dy5iYWlkdS5jb20=
  
     QByteArray ba("aHR0cDovL3d3dy5iYWlkdS5jb20=");
     QByteArray::FromBase64Result result = QByteArray::fromBase64Encoding(ba, QByteArray::Base64Encoding);
     qDebug()<< result.operator bool();
     qDebug()<< *result;
 
  

 2、QByteArray toBase64(QByteArray::Base64Options options = Base64Encoding)
 
  
返回字节数组的副本，使用选项选项进行编码。
 
  
    QByteArray text("http://www.baidu.com");
     qDebug()<< text.toBase64();                                                                 
     qDebug()<< text.toBase64(QByteArray::Base64Encoding | QByteArray::OmitTrailingEquals);      
     qDebug()<< text.toBase64(QByteArray::Base64Encoding);                                       
     qDebug()<< text.toBase64(QByteArray::Base64UrlEncoding);                                    
     qDebug()<< text.toBase64(QByteArray::Base64UrlEncoding | QByteArray::OmitTrailingEquals);
 
  

  3、QByteArray(qsizetype size, char ch)
 
  
构造一个大小为 size 的字节数组，每个字节都设置为 ch。
 
  
4、QByteArray(const char *data, qsizetype size = -1)
 
  
构造一个包含数组 data 的前size个字节的字节数组。
 
  
如果 data 为 nullptr，则构造空字节数组。
 
  
如果 size 为负，则假定数据指向以 '\0' 结尾的字符串，并且其长度是动态确定的。
 
  
此函数会深拷贝。
 
  
5、QByteArray & append(const QByteArray &ba) / void push_back(const QByteArray &other)
 
  
将字节数组 ba 附加到此字节数组的末尾。
 
  
等同于 insert(size(), ba) 相同。
 
  
append() 函数通常非常快（恒定时间），因为 QByteArray 在数据的末尾预先分配了额外的空间，因此它可以增长而无需每次重新分配整个数组。
 
  
QByteArray & append(char ch) / void push_back(char ch)
 
  
QByteArray & append(qsizetype count, char ch)
 
  
将 ch 的 count 个副本附加到此字节数组并返回对此字节数组的引用。
 
  
如果 count 为负数或零，则不会向字节数组附加任何内容。
 
  
QByteArray & append(const char *str) / void push_back(const char *str)
 
  
将以 '\0' 结尾的字符串 str 附加到此字节数组。
 
  
QByteArray & append(const char *str, qsizetype len)
 
  
将从 str 开始的前 len 个字节追加到此字节数组并返回对此字节数组的引用。附加的字节可能包括 '\0' 字节。
 
  
如果 len 为负，则 str 将被假定为以 '\0' 结尾的字符串，并且将使用 qstrlen() 自动确定要复制的长度。
 
  
如果 len 为零或 str 为 nullptr，则不会向字节数组附加任何内容。
 
  
应确保 len 不长于 str。
 
  
QByteArray & append(QByteArrayView data) / void push_back(QByteArrayView str)
 
  
6、char at(qsizetype i) 
 
  
     char operator[](qsizetype i)
 
  
     char & operator[](qsizetype i)
 
  
返回字节数组中索引位置 i 处的字节。必须 0 <= i < size()。
 
  
7、char back() 
 
  
     char & back()
 
  
返回字节数组中的最后一个字节。与 at(size() - 1) 相同。
 
  
警告：在空字节数组上调用此函数构成未定义行为。
 
  
8、qsizetype capacity()
 
  
返回在不强制重新分配的情况下可以存储在字节数组中的最大字节数。
 
  
这个函数的唯一目的是提供一种微调 QByteArray 内存使用的方法。通常不需要调用此函数。如果想知道字节数组中有多少字节应调用 size()。
 
  
9、void chop(qsizetype n)
 
  
从字节数组的末尾删除 n 个字节。
 
  
如果 n 大于 size()，则结果是一个空字节数组。如果 n 为负数则结果不变。
 
  
QByteArray ba("STARTTLS\r\n");
 ba.chop(2); // ba == "STARTTLS"
 10、QByteArray chopped(qsizetype len) 
 
  
返回一个字节数组，其中包含最左边的 size() - 此字节数组的 len 个字节。
 
  
如果 len 为负数或大于 size()，则行为未定义。
 
  
QByteArray ba("STARTTLS\r\n");
 QByteArray ba2 = ba.chopped(2); // ba2 == "STARTTLS"  ba == "STARTTLS\r\n"
 11、void clear()
 
  
清空内容。
 
  
12、int compare(QByteArrayView bv, Qt::CaseSensitivity cs = Qt::CaseSensitive) 
 
  
比较字节数组，返回0则字符串相同。
 
  
13、const char * constData()
 
  
       const char * data()
 
  
返回指向存储在字节数组中的常量数据的指针。指针可用于访问组成数组的字节。
 
  
此函数主要用于将字节数组传递给接受 const char * 的函数。
 
  
QByteArray 可以存储任何字节值，包括 '\0'，但大多数采用 char * 参数的函数假定数据在它们遇到的第一个 '\0' 处结束。
 
  
14、bool contains(QByteArrayView bv) 
 
  
       bool contains(char ch)    
 
  
是否包含。
 
  
15、qsizetype count(char ch) 
 
  
       qsizetype count(QByteArrayView bv) 
 
  
       qsizetype count() 
 
  
计数。
 
  
16、char * data()
 
  
返回指向存储在字节数组中的数据的指针。指针可用于访问和修改组成数组的字节。 数据以 '\0' 结尾。
 
  
对于只读访问， constData() 更快，因为它永远不会导致发生深拷贝。
 
  
 QByteArray ba("Hello world");
  char *data = ba.data();
  while (*data) 
  {
      cout << "[" << *data << "]" << Qt::endl;
      ++data;
  }
 下面的示例复制了 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;
 17、bool endsWith(QByteArrayView bv) 
 
  
        bool endsWith(char ch) 
 
  
是否以...结尾。
 
  
18、QByteArray::iterator erase(QByteArray::const_iterator first，QByteArray::const_iterator last)
 
  
从字节数组中删除半开范围 [first , last ) 中的字符。返回指向 last 引用的字符的迭代器。
 
  
19、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"
 20、QByteArray first(qsizetype n) 
 
  
返回字节数组的前 n 个字节。当 n < 0 或 n > size() 时，行为未定义。
 
  
QByteArray x("Pineapple");
 QByteArray y = x.first(4);// y == "Pine"
 QByteArray left(qsizetype len) 
 
  
返回此字节数组的前 len 个字节。
 
  
如果已知 len 不能越界，请使用 first() ，因为它更快。
 
  
如果 len 大于 size()，则返回整个字节数组。如果 len 小于 0，则返回一个空字节数组。
 
  
21、【static】QByteArray fromHex(const QByteArray &hexEncoded)
 
  
返回十六进制编码数组的解码副本。输入中的无效字符将被跳过。
 
  
22、QByteArray toHex(char separator = '\0') 
 
  
返回字节数组的十六进制编码副本。十六进制编码使用数字 0-9 和字母 a-f（小写）。
 
  
如果分隔符不是 '\0'，则分隔符插入到十六进制字节之间。
 
  
    QByteArray macAddress = QByteArray::fromHex("123456abcdef");
     qDebug()<< macAddress.toHex();//returns "123456abcdef"
     qDebug()<< macAddress.toHex(':'); // returns "12:34:56:ab:cd:ef"
     qDebug()<< macAddress.toHex(0);   // returns "123456abcdef"
 23、【static】QByteArray fromRawData(const char *data, qsizetype size)
 
  
构造一个使用 data 数组的 size 字节的 QByteArray。
 
  
警告：使用 fromRawData() 创建的字节数组可能不是以 '\0' 结尾的。将字节数组传递给接受预期为 '\0' 终止的 const char * 的函数将失败。
 
  
    char mydata[] = {'\x00', '\x01', '\x02', '\x03'};//不是'\0'结尾
     QByteArray data = QByteArray::fromRawData(mydata, sizeof(mydata));
 23、QByteArray fromStdString(const std::string &str)
 
  
标准库字符串转字节数组。
 
  
24、char front() 
 
  
       char & front()
 
  
返回字节数组中的第一个字节。 在空字节数组上调用此函数构成未定义行为。
 
  
25、qsizetype indexOf(QByteArrayView bv, qsizetype from = 0)
 
  
        qsizetype indexOf(char ch, qsizetype from = 0)
 
  
返回参数1首次出现的索引位置，如果未找到匹配项，则返回 -1。
 
  
       qsizetype lastIndexOf(QByteArrayView bv, qsizetype from = -1)
 
  
       qsizetype lastIndexOf(char ch, qsizetype from = -1) 
 
  
返回参数1首次出现的索引位置，如果未找到匹配项，则返回 -1。
 
  
如果 from 是 -1（默认值），则从字节数组的末尾开始搜索。
 
  
26、QByteArray & insert(qsizetype i, QByteArrayView data)
 
  
       QByteArray & insert(qsizetype i, const char *s)
 
  
       QByteArray & insert(qsizetype i, const QByteArray &data)
 
  
       QByteArray & insert(qsizetype i, char ch)
 
  
插入。对于大字节数组，此操作可能很慢（线性时间），因为它需要将索引 i 及以上的所有字节在内存中至少移动一个位置。
 
  
如果 i 超出数组的末尾，则首先使用空格字符扩展数组以到达 i。
 
  
        QByteArray & insert(qsizetype i, qsizetype count, char ch)
 
  
在字节数组中的索引位置 i 处插入字节 ch 的 count 个副本。
 
  
如果 i 超出数组的末尾，则首先使用空格字符扩展数组以到达 i。
 
  
       QByteArray & insert(qsizetype i, const char *data, qsizetype len) 
 
  
在字节数组中的位置 i 插入data中的 len 个字节。
 
  
如果 i 超出数组的末尾，则首先使用空格字符扩展数组以到达 i。
 
  
27、bool isLower() / bool isUpper() 
 
  
如果此字节数组是否仅包含小写 / 大写 ASCII 字母。
 
  
       QByteArray toLower() / QByteArray toUpper() 
 
  
转为小写/大写。
 
  
28、QByteArray last(qsizetype n) 
 
  
返回字节数组的最后 n 个字节。注意：当 n < 0 或 n > size() 时，行为未定义。
 
  
       QByteArray right(qsizetype len) 
 
  
返回一个字节数组，其中包含此字节数组的最后 len 个字节。
 
  
如果已知 len 不会越界，请使用 last() ，因为它更快。
 
  
如果 len 大于 size()，则返回整个字节数组。如果 len 小于 0，则返回一个空的数组。 
 
  
29、QByteArray leftJustified(qsizetype width, char fill = ' ', bool truncate = false) 
 
  
返回一个大小为 width 的字节数组，其中包含用 fill 字节填充的此字节数组。
 
  
如果 truncate 为 false 并且字节数组的 size() 大于width，则返回的字节数组是该字节数组的副本。
 如果 truncate 为 true 并且字节数组的 size() 大于width，则删除位置 width 之后字节数组副本中的任何字节，并返回副本。
     QByteArray x("apple");
     qDebug()<< x.leftJustified(8, '.',false);
     qDebug()<< x.leftJustified(8, '.',true);
     qDebug()<< x.leftJustified(2, '.',false);
     qDebug()<< x.leftJustified(2, '.',true);
 
  

        QByteArray rightJustified(qsizetype width, char fill = ' ', bool truncate = false) 
 
  
返回大小为 width 的字节数组，其中包含后跟此字节数组的填充字节。
 
  
如果 truncate 为 false 并且字节数组的大小大于宽度，则返回的字节数组是该字节数组的副本。
 如果 truncate 为 true 并且字节数组的大小大于宽度，则生成的字节数组在位置 width 处被截断。
     QByteArray x("apple");
     qDebug()<< x.rightJustified(8, '.',false);
     qDebug()<< x.rightJustified(8, '.',true);
     qDebug()<< x.rightJustified(2, '.',false);
     qDebug()<< x.rightJustified(2, '.',true);
 
  

 30、QByteArray sliced(qsizetype pos, qsizetype n) 
 
  
返回一个字节数组，其中包含从位置 pos 开始的 n 个字节。
 
  
当 pos < 0、n < 0 或 pos + n > size() 时，行为未定义。
 
  
       QByteArray sliced(qsizetype pos) 
 
  
返回一个字节数组，其中包含从该对象中位置 pos 开始并延伸到该对象末尾的字节。
 
  
当 pos < 0 或 pos > size() 时，行为未定义。
 
  
 QByteArray x("Five pineapples");
  QByteArray y = x.sliced(5, 4);     // y == "pine"
  QByteArray z = x.sliced(5);        // z == "pineapples"
        QByteArray mid(qsizetype pos, qsizetype len = -1) 
 
  
返回一个字节数组，该数组包含此字节数组中的 len 个字节，从位置 pos 开始。
 
  
如果已知 pos 和 len 不能越界，请使用 sliced() ，因为它更快。
 
  
如果 len 为 -1（默认值）或 pos + len >= size()，则返回一个字节数组，其中包含从位置 pos 开始到字节数组末尾的所有字节。
 
  
31、[static] QByteArray number(int n, int base = 10)
 
  
       [static]  QByteArray number(uint n, int base = 10)
 
  
       [static]  QByteArray number(long n, int base = 10)
 
  
       [static]  QByteArray number(ulong n, int base = 10)
 
  
       [static]  QByteArray number(qlonglong n, int base = 10)
 
  
       [static]  QByteArray number(qulonglong n, int base = 10)
 
  
数字转字节数组。支持基数 2 到 36。
 
  
    qDebug()<< QByteArray::number(0xaceb,2);
     qDebug()<< QByteArray::number(0xaceb,10);
     qDebug()<< QByteArray::number(0xaceb,16);
 
  

        [static]  QByteArray number(double n, char f = 'g', int prec = 6)
 
  
返回一个字节数组，其中包含 n 的打印值，格式为 f，精度为 prec。
 
  
参数 n 根据指定的 f 格式进行格式化：
 
  
e：格式为[-]9.9e[+|-]999
 E：格式为[-]9.9E[+|-]999
 f：格式为[-]9.9
 g：使用e或f格式，以最简洁的为准
 G：使用E或f格式，以最简洁的为准
 对于 'e'、'E' 和 'f'，prec 是小数点后的位数。
 
  
对于 'g' 和 'G'，prec 是有效数字的最大数量（省略尾随零）。
 
  
    qDebug()<< QByteArray::number(12.3456, 'e', 3);
     qDebug()<< QByteArray::number(12.3456, 'E', 3);
     qDebug()<< QByteArray::number(12.3456, 'f', 3);
     qDebug()<< QByteArray::number(12.3456, 'g', 3);
     qDebug()<< QByteArray::number(12.3456, 'G', 3);
 
  

        QByteArray & setNum(int n, int base = 10)
 
  
       QByteArray & setNum(short n, int base = 10)
 
  
       QByteArray & setNum(ushort n, int base = 10)
 
  
       QByteArray & setNum(uint n, int base = 10)
 
  
       QByteArray & setNum(long n, int base = 10)
 
  
       QByteArray & setNum(ulong n, int base = 10)
 
  
       QByteArray & setNum(qlonglong n, int base = 10)
 
  
       QByteArray & setNum(qulonglong n, int base = 10)
 
  
将字节数组设置为基数中的 n 值，并返回对字节数组的引用。支持基数 2 到 36。
 
  
 QByteArray ba;
  int n = 63;
  ba.setNum(n);           // ba == "63"
  ba.setNum(n, 16);       // ba == "3f"
        QByteArray & setNum(float n, char f = 'g', int prec = 6) 
 
  
       QByteArray & setNum(double n, char f = 'g', int prec = 6)
 
  
    QByteArray ba;
     ba.setNum(12.3456,'e',3);//"1.235e+01"
     ba.setNum(12.3456,'E',3);//"1.235E+01"
     ba.setNum(12.3456,'f',3);//"12.346"
     ba.setNum(12.3456,'g',3);//"12.3"
     ba.setNum(12.3456,'G',3);//"12.3"
 32、QByteArray & prepend(QByteArrayView ba) / void push_front(QByteArrayView str)
 
  
       QByteArray & prepend(const QByteArray &ba) / void push_front(const QByteArray &other)
 
  
       QByteArray & prepend(char ch) / void push_front(char ch)
 
  
       QByteArray & prepend(const char *str) / void push_front(const char *str)
 
  
在前面添加内容。此操作通常非常快（恒定时间），因为 QByteArray 在数据的开头预先分配了额外的空间，所以它可以增长而无需每次重新分配整个数组。
 
  
       QByteArray & prepend(qsizetype count, char ch)
 
  
将字节 ch 的 count 个副本添加到前面。 
 
  
       QByteArray & prepend(const char *str, qsizetype len)
 
  
添加 str 的 len 个字节。
 
  
33、QByteArray & remove(qsizetype pos, qsizetype len)
 
  
从索引位置 pos 开始，从数组中删除 len 个字节，并返回对数组的引用。
 
  
如果 pos 超出范围，则什么也不会发生。 如果 pos 有效，但 pos + len 大于数组的大小，则数组在位置 pos 处被截断。
 
  
元素删除将保留数组的容量，而不是减少分配的内存量。 为了减少额外的容量并释放尽可能多的内存，请在最后一次更改数组大小后调用 squeeze()。
 
  
34、template  QByteArray & removeIf(Predicate pred)
 
  
从字节数组中删除谓词 pred 为其返回 true 的所有字节。 返回对字节数组的引用。
 
  
    QByteArray ba("123456789");
     qDebug()<     {
         return a > '5';
     });//"12345"
 35、QByteArray repeated(qsizetype times) 
 
  
返回重复指定次数的此字节数组的副本。如果次数小于 1，则返回一个空字节数组。
 
  
 QByteArray ba("ab");
  ba.repeated(4);  // "abababab"
 36、QByteArray & replace(qsizetype pos, qsizetype len, QByteArrayView after)
 
  
用后面的字节数组替换索引位置 pos 的 len 个字节，并返回对此字节数组的引用。
 
  
 QByteArray x("Say yes!");
  QByteArray y("no");
  x.replace(4, 3, y); // x == "Say no!"
        QByteArray & replace(qsizetype pos, qsizetype len, const char *after, qsizetype alen)
 
  
将 len 字节从索引位置 pos 替换为从位置 after 开始的 alen 字节。
 
  
       QByteArray & replace(char before，QByteArrayView after)
 
  
       QByteArray & replace(QByteArrayView before, QByteArrayView after)
 
  
参数2替换参数1。
 
  
       QByteArray & replace(const char *before, qsizetype bsize, const char *after, qsizetype asize)
 
  
将每次出现的 bsize 字节从 before 开始的子串替换为 asize 字节从 after 开始的子串。
 
  
37、void reserve(qsizetype size)
 
  
尝试为至少 size 个字节分配内存。如果事先知道字节数组有多大，可以调用这个函数。
 
  
此函数的唯一目的是提供一种微调 QByteArray 内存的方法。通常很少需要调用此函数。
 
  
38、void resize(qsizetype size)
 
  
如果 size 大于当前大小，则扩展字节数组以使其大小为字节，并将额外的字节添加到末尾。新字节未初始化。
 
  
如果 size 小于当前大小，则超出位置大小的字节将从字节数组中排除（容量不变）。
 
  
虽然 resize() 会在需要时增加容量，但它永远不会缩小容量。要去掉多余的容量可使用 squeeze()。
 
  
39、QByteArray & setRawData(const char *data, qsizetype size)
 
  
使用 data 数组的 size 个字节重置 QByteArray。
 
  
可使用此函数代替 fromRawData() 重新使用现有的 QByteArray 对象以节省内存重新分配。
 
  
40、void squeeze() / void shrink_to_fit()
 
  
释放任何不需要存储阵列数据的内存。
 
  
此函数的唯一目是提供一种微调 QByteArray 内存使用的方法。 通常很少需要调用此函数。
 
  
41、QByteArray simplified() 
 
  
返回此字节数组的副本，该副本从开头和结尾删除了间距字符（制表 '\t'、换行 '\n'、回车 '\r'、垂直制表 '\v'、换页 '\f' 、空格 ' '），多个空格用一个空格代替。
 
  
 QByteArray ba("  lots\t of\nwhitespace\r\n ");
  ba = ba.simplified();//"lots of whitespace";
 42、qsizetype size() / qsizetype length() 
 
  
返回此字节数组中的字节数。
 
  
字节数组中的最后一个字节在 size() - 1 位置。 另外，QByteArray 确保 size() 位置的字节始终为 '\0'，这样就可以使用 data() 和 constData() 的返回值 作为期望以 '\0' 结尾的字符串的函数的参数。如果 QByteArray 对象是从不包含尾随 '\0' 终止字节的原始数据创建的，那么 QByteArray 不会自动添加它，除非创建了深层副本。
 
  
43、QList split(char sep) 
 
  
在 sep 出现的任何地方将字节数组拆分为子数组，并返回这些数组的列表。 如果 sep 与字节数组中的任何位置都不匹配，split() 将返回一个包含此字节数组的单元素列表。
 
  
44、bool startsWith(QByteArrayView bv) 
 
  
       bool startsWith(char ch) 
 
  
是否以开头。
 
  
45、double toDouble(bool *ok = nullptr) 
 
  
       float toFloat(bool *ok = nullptr)
 
  
转数字。如果 ok 不是 nullptr，*ok 报告结果。
 
  
警告： QByteArray 内容只能包含有效的数字字符，即包括加号/减号、科学记数法中使用的字符 e 和小数点。若包含单位或附加字符会导致转换错误。
 
  
 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
        int toInt(bool *ok = nullptr, int base = 10) 
 
  
       long toLong(bool *ok = nullptr, int base = 10) 
 
  
       qlonglong toLongLong(bool *ok = nullptr, int base = 10) 
 
  
       ushort toUShort(bool *ok = nullptr, int base = 10) 
 
  
支持 base 0 和 2 到 36。
 如果 base为 0，则使用以下规则自动确定基数：
 
  
如果以“0x”开头，则假定为十六进制（基数为 16）
 如果以“0”开头，则假定为八进制（基数为 8）
 其他情况假定为十进制
 如果转换失败，则返回 0。
 
  
 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
 46、QByteArray trimmed()
 
  
返回此字节数组的副本，其中从开头和结尾删除了间距字符。
 
  
制表 '\t'、换行 '\n'、回车 '\r'、垂直制表 '\v'、换页 '\f' 、空格 ' '。 
 
  
 47、void truncate(qsizetype pos)
 
  
在索引位置 pos 处截断字节数组。如果 pos 超出数组的末尾，则什么也不会发生。
 
  
 QByteArray ba("Stockholm");
  ba.truncate(5);             // ba == "Stock"
 48、bool operator!=(const QString &str) / bool operator==(const QString &str)
 
  
此字节数组是否不等于 / 等于 str 的 UTF-8 编码。比较区分大小写。
 
  
可以通过在编译应用程序时定义 QT_NO_CAST_FROM_ASCII 来禁用此运算符。
 
  
如果想在进行比较之前将字节数组转换为 QString，则需要显式调用 QString::fromUtf8()、QString::fromLatin1() 或 QString::fromLocal8Bit()。
 
  
49、QByteArray & operator+=(const QByteArray &ba)
 
  
       QByteArray & operator+=(char ch)
 
  
       QByteArray & operator+=(const char *str)
 
  
在后面追加。
 
  
四、相关非成员
 1、template  qsizetype erase(QByteArray &ba, const T &t)
 
  
删除等于参数2的元素。返回删除的元素个数
 
  
    QByteArray ba("123456789");
     qsizetype n = erase(ba,'1');
     qDebug()<< ba;//"23456789"
     qDebug()<< n;//1
 2、 template  qsizetype erase_if(QByteArray &ba, Predicate pred)
 
  
删除满足条件的元素。
 
  
3、quint16 qChecksum(QByteArrayView data, Qt::ChecksumType standard = Qt::ChecksumIso3309)
 
  
返回数据的 CRC-16 校验码。
 
  
enum：Qt::ChecksumType
 
  
Qt::ChecksumIso3309：Checksum 计算基于 ISO 3309。
 Qt::ChecksumItuV41：Checksum 计算基于 ITU-V.41。
 4、QByteArray qCompress(const QByteArray &data, int compressionLevel = -1)
 
  
     QByteArray qCompress(const uchar *data, qsizetype nbytes, int compressionLevel = -1)
 
  
压缩数据字节数组，并以新的字节数组形式返回压缩后的数据。
 
  
compressionLevel 参数指定压缩速度。有效值介于 0 和 9 之间，其中 9 对应于使用较慢算法的最大压缩（即较小的压缩数据）。 较小的值 (8, 7, ..., 1) 以稍快的速度连续提供较少的压缩。 值 0 对应于根本没有压缩。 默认值为 -1，指定 zlib 的默认压缩。
 
  
5、 QByteArray qUncompress(const QByteArray &data)
 
  
       QByteArray qUncompress(const uchar *data, qsizetype nbytes)
 
  
解压缩数据字节数组并返回一个包含未压缩数据的新字节数组。
 
  
如果输入数据已损坏，则返回一个空的 QByteArray。
 此函数将使用 qCompress() 从该版本和任何较早的 Qt 版本解压缩数据，并在添加此功能时将其解压缩回 Qt 3.1。
 
  
注意：如果要使用此函数解压缩使用 zlib 压缩的外部数据，首先需要在包含数据的字节数组前添加一个四字节的标头。 标头必须包含未压缩数据的预期长度（以字节为单位），表示为无符号、大端、32 位整数。
 
  
注：不要用此函数压缩文件。
 
  
五、宏
 1、QT_NO_CAST_FROM_BYTEARRAY
 
  
禁用从 QByteArray 到 const char * 或 const void * 的自动转换。
 
  
2、QByteArrayLiteral(ba)
 
  
该宏在编译时从字符串文字 ba 中生成 QByteArray 的数据。在这种情况下，从它创建一个 QByteArray 是低代价的，生成的字节数组数据存储在编译目标文件的只读段中。
 
  
使用 QByteArrayLiteral 代替双引号普通 C++ 字符串文字可以显着加快从编译时已知数据创建 QByteArray 实例的速度。
 
  
 QByteArray ba = QByteArrayLiteral("byte array contents");
 Qt6.2之后上面的代码可写作：
 
  
 auto ba = "byte array contents"_qba;