准备：认识Protobuf

概念：Protobuf（Google Protocol Buffers）是谷歌提供的一个具有搞笑的协议数据交换格式的工具库（类似Json数据格式），时间和空间效率上都比Json要好一些。目前还不是太流行，仅支持C++、JAVA、python语言的开发。

重点关注：ProtoBuf中数据序列与反序列的规则

protobuf把消息结果message也是通过 key-value键值对来表示。只是其中的key是采取一定的算法计算出来的即通过每个message中每个字段(field index)和字段的数据类型(type)进行运算得来:
key = (index << 3) | type
field index = key >> 3
type = key & 0x111

  • type类型的对应关系如下： | type | mean | used for | | —- | —- | —- | | 0 | varint | int32, int64, uint32, uint64, sint32, sint64, bool, enum | | 1 | 64-bit | fixed64, sfixed64, double | | 2 | length-delimited | string, bytes, embedded messages, packed repeated fields | | 3 | start group | groups (deprecated) | | 4 | end group | groups (deprecated) | | 5 | 32-bit | fixed32, sfixed32, float |

准备：认识varint编码

概念：varint是一种使用1字节~多字节序列化一个整数的方法，会根据一个整数的数值大小对应编码变长的存储字节大小。32int型数据经varint编码后需要1~5字节；64int型数据经varint编码后需要1~10字节。通常，在实际应用场景中，小数字的使用远多于大数字，varint编码能够起到很好的压缩效果，节省空间。

· 编码原理

  1. 除最后一个字节外，每一个字节的最高位都有特殊的意义，即：最高有效位（most significant bit —msb），msb = 1表明后面的数据还是属于当前数据；msb = 0表明这已经是当前数据已经结束。
  2. 每个字节的低7位用于以7位为一组存储数字的二进制补码表示，且按照小端字节序排列。

  • 例子1，将数字uint32_t = 123456进行varint编码

    1.             123456
    2.               |            
    3. 0000 0000 000|0 0001 11|10 0010 0|100 0000         ------二进制补码表示  4字节表示
    4.               |
    5.               |    每7bit划分，添加msb重新编码,从低位到高位取，并反转排序
    6.               |
    7. 1|1000000   1|1000100   0|0000111  
    8. 0xC0          0xC4        0x07               --------varint编码后的数据 3字节表示

  • 例子2，将数字uint32_t = 665进行varint编码

    1.              665
    2.               |
    3. 0000 0000 0000 0000 00|00 0010 1|001 1001            ------二进制补码表示  4字节表示
    4.               |
    5.               |    每7bit划分，添加msb重新编码,从低位到高位取，并反转排序
    6.               |
    7.    1|0011001    0|0000101   
    8.      0X99            0X05                    --------varint编码后的数据 2字节表示

  • 例子3，将数字int32_t = -1进行varint编码（可以看到有时候对负数的压缩编码效率低下）

    1.              -1
    2.               |
    3. 1111 |1111 111|1 1111 11|11 1111 1|111 1111            ------二进制补码表示  4字节表示
    4.               |
    5.               |    每7bit划分，添加msb重新编码,从低位到高位取，并反转排序
    6.               |
    7. 1|1111111  1|1111111  1|1111111  1|1111111  0|0001111 
    8.  0xff          0xff        0xff        0xff       0x0f     ------varint编码后的数据 5字节表示

  • 例子4，将数字int32_t = -123进行varint编码（可以看到有时候对负数的压缩编码效率低下）

    1.              -123
    2.               |
    3. 1111 |1111 111|1 1111 11|11 1111 1|000 0101            ------二进制补码表示  4字节表示
    4.               |
    5.               |    每7bit划分，添加msb重新编码,从低位到高位取，并反转排序
    6.               |
    7. 1|0000101 1|1111111  1|1111111  1|1111111  0|0001111 
    8.  0x85          0xff        0xff        0xff       0x0f     ------varint编码后的数据 5字节表示

1. ByteArray 类封装

目的：网络编程中势必涉及到数据包的封装、传递等操作。将这些数据的序列化和反序列化操作抽象到一个类中来管理，有点类似”内存池”的管理，但不是真正的内存池。

注意：涉及网络编程，小心数据包传递、组装还原时候字节序问题

1.1 成员变量

  1. class ByteArray
  2. {
  3.     ...
  4.     ...
  5. private:
  6.     //每一个内存块有多大
  7.     size_t m_baseSize;
  8.     //当前操作指针的位置
  9.     size_t m_position;
  10.     //总共容量大小
  11.     size_t m_capacity;
  12.     //已经使用的空间大小
  13.     size_t m_size;
  14.     //数据字节序(大端/小端)
  15.     int8_t m_endian;
  16.     //内存结点个数
  17.     size_t m_nodeSum;
  18.     //内存链表头结点
  19.     Node* m_root;
  20.     //内存链表尾结点
  21.     Node* m_cur;
  23. };

1.2 接口

1.2.1 构造函数

  1. /**
  2.  * @brief ByteArray类构造函数
  3.  * @param base_size 传入的指定内存块的大小 默认为4KB
  4.  */
  5. ByteArray(size_t base_size = 4 * 1024);
  7. ByteArray::ByteArray(size_t base_size)
  8.     :m_baseSize(base_size)
  9.     ,m_position(0)
  10.     ,m_capacity(base_size)
  11.     ,m_size(0)
  12.     ,m_endian(KIT_BIG_ENDIAN)   //网络字节序是大端
  13.     ,m_root(new Node(base_size))
  14.     ,m_cur(m_root)
  15. {
  17. }

1.2.2 析构函数

功能：负责将申请的内存结点，逐一手动释放

  1. /**
  2.  * @brief ByteArray类析构函数
  3.  */
  4. ~ByteArray();
  6. ByteArray::~ByteArray()
  7. {
  8.     //释放内存链表
  9.     Node* temp = m_root;
  10.     while(temp)
  11.     {
  12.         m_cur = temp;
  13.         temp = temp->next;
  14.         delete m_cur;
  15.     }
  17. }

** 私有接口 （核心）

1). addCapacity()

功能：给内存扩容，指定扩容空间大小

  • 核心逻辑：
  1. 获取当前内存剩余的容量，和传入的要写入的数据size比较。remain_cap >= size就不用扩容
  2. 计算出需要扩容的容量大小，根据该大小和单个内存结点大小，计算需额外添加结点的数量

size_t count = ceil(1.0 * size / m_baseSize);（进行上取整）

  1. 找到尾部结点的位置，开始从该位置采用尾插添加新的结点。并且要记录第一个新添加的结点位置
  2. 如果之前获取的剩余容量的大小刚好为0，要将指示当前可用结点指针m_cur置为第一个新添加结点 ```cpp /**
    • @brief 给内存扩容
    • @param[in] size 需要扩大的容量大小 */ void addCapacity(size_t size);

void ByteArray::addCapacity(size_t size) { if(size == 0) return;

  1. //获取剩余的容量
  2. size_t remain_cap = getRemainCapacity();
  3. if(remain_cap >= size)
  4.     return;
  7. //减去原有的容量
  8. size = size - remain_cap;
  9. //计算需额外添加结点的数量
  10. size_t count = ceil(1.0 * size / m_baseSize);
  12. //找到尾部内存块结点的位置
  13. Node *temp = m_root;
  14. while(temp->next)
  15. {
  16.     temp = temp->next;
  17. }
  19. //从尾部开始尾插法添加新结点
  20. Node *first = nullptr;
  21. for(size_t i = 0;i < count;++i)
  22. {
  23.     temp->next = new Node(m_baseSize);
  24.     //将新加入的第一个结点记录一下便于连接
  25.     if(first == nullptr)
  26.     {
  27.         first = temp->next;
  28.     }
  30.     temp = temp->next;
  31.     m_capacity += m_baseSize;
  32. }
  34. //如果原来的容量恰好用完 要把m_cur置到第一个新结点上
  35. if(remain_cap == 0)
  36.     m_cur = first;

}

  2. <a name="rBUqv"></a>
  3. #### 2). `getRemainCapacity()`
  4. 功能：计算返回当前内存剩余容量大小。
  5. ```cpp
  6. /**
  7.  * @brief 获取能使用的剩余容量大小
  8.  * @return size_t 
  9.  */
  10. size_t getRemainCapacity() const {return m_capacity - m_position;}

** 辅助函数（重点）

目的：将有符号的数都转为无符号数进行varint压缩，避免出现负数压缩的情况。因为varint算法对负数压缩的效率很低下。存入时候负——>正，取出时候恢复正——->负

1). EncodeZigzag32()/DecodeZigzag32()

功能：int32_t—————>uint32_t / uint32_t—————>int32_t

  1. /**
  2.  * @brief  int32_t---------->uint32_t
  3.  * @param[in] v  传入的int32_t数据
  4.  * @return uint32_t 
  5.  */
  6. static uint32_t EncodeZigzag32(const int32_t &v)
  7. {
  8.     //不转换的话 负数压缩会浪费空间
  9.     if(v < 0)
  10.     {
  11.         return ((uint32_t)(-v)) * 2 - 1;
  12.     }
  14.     return v * 2;
  15. }
  17. /**
  18.  * @brief uint32_t---------->int32_t
  19.  * @param[in] v  传入的uint32_t数据
  20.  * @return int32_t 
  21.  */
  22. static int32_t DecodeZigzag32(const uint32_t &v)
  23. {
  24.     //消除乘2  异或一下最后一位来恢复负数
  25.     return (v >> 1) ^ -(v & 1);
  26. }

2). EncodeZigzag64()/DecodeZigzag64()

功能：int64_t—————>uint64_t / uint64_t—————>int64_t

  1. /**
  2.  * @brief  int64_t---------->uint64_t
  3.  * @param[in] v  传入的int64_t数据
  4.  * @return uint64_t 
  5.  */
  6. static uint64_t EncodeZigzag64(const int64_t &v)
  7. {
  8.     //不转换的话 -1压缩一定要消耗10个字节
  9.     if(v < 0)
  10.     {
  11.         return ((uint64_t)(-v)) * 2 - 1;
  12.     }
  14.     return v * 2;
  15. }
  17. /**
  18.  * @brief int64_t---------->uint64_t
  19.  * @param[in] v  传入的int64_t数据
  20.  * @return int64_t 
  21.  */
  22. static int64_t DecodeZigzag64(const uint64_t &v)
  23. {
  24.     //消除乘2  异或一下最后一位来恢复负数
  25.     return (v >> 1) ^ -(v & 1);
  26. }

1.2.3 写系列函数

1.2.3.1 write()（核心）

功能：将缓冲区的内容写入到内存块中

  • 核心逻辑：
  1. 保险起见，先将总容量再扩展size个字节addCapacity(size)
  2. 获取当前内存块的相关信息：内存指针内存块哪一个字节上，内存块剩余容量等

while(size >0) 只要待写入数据量不为0就要一直写入
{

  1. 开始将数据从缓冲区写入内存块：
    1. 当前内存块剩余容量ncap >= 缓冲区数据量size:

当前结点能够放下缓冲区的全部数据。

  1. 当前内存块剩余容量ncap < 缓冲区数据量size:

当前结点只能够放下缓冲区的一部分数据，另外一部分数据需要放入下一个内存块中，发生”数据断层”。
}

  1. 最后，内存指针的位置m_position > 已经使用的内存空间m_size，需要更新一下已使用内存。 ```cpp /**
    • @brief 将数据写入内存
    • @param[in] buf 写入缓冲区指针
    • @param[in] size 要写入的字节大小 / void write(const void buf, size_t size);

void ByteArray::write(const void * buf, size_t size) { if(size == 0) return;

  1. //扩展容量size
  2. addCapacity(size);
  3. //内存指针现在在内存块结点哪一个字节位置上
  4. size_t npos = m_position % m_baseSize;
  5. //当前结点的剩余容量
  6. size_t ncap = m_cur->size - npos;
  7. //已经写入内存的数据量
  8. size_t bpos = 0;
  10. while(size > 0)
  11. {
  12.     //内存结点当前剩余容量能放下size的数据
  13.     if(ncap >= size)
  14.     {
  15.         memcpy(m_cur->ptr + npos, (const char*)buf + bpos, size);
  16.         //如果当前结点恰好被写完 也要把内存指针移到下一个内存块上
  17.         if(m_cur->size == (npos + size))
  18.             m_cur = m_cur->next;
  20.         m_position += size;
  21.         bpos += size;
  22.         size = 0;
  24.     }
  25.     else    //否则就是不够放 先把当前剩余空间写完 在下一个新结点继续写入
  26.     {
  27.         memcpy(m_cur->ptr + npos, (const char *)buf + bpos, ncap);
  28.         m_position += ncap;
  29.         bpos += ncap;
  30.         size -= ncap;
  32.         //去遍历下一个内存块
  33.         m_cur = m_cur->next;
  34.         ncap = m_cur->size;
  35.         npos = 0;
  37.     }
  39. }
  41. //如果内存指针超过了当前表示的已经使用的空间大小 更新一下
  42. if(m_position > m_size)
  43.     m_size = m_position;

}

  1. <a name="JTVyQ"></a>
  2. #### 1.2.3.2 写入固定长度数据
  3. 除了1字节长度的数据，其他 >1字节的数据需要检查存储的数据字节序是否和用户物理机的字节序相同，不同需要进行字节序调整交换。
  4. ```cpp
  5. /*固定长度存储*/
  6. void writeFint8(int8_t value);
  7. void writeFuint8(uint8_t value);
  8. void writeFint16(int16_t value);
  9. void writeFuint16(uint16_t value);
  10. void writeFint32(int32_t value);
  11. void writeFuint32(uint32_t value);
  12. void writeFint64(int64_t value);
  13. void writeFuint64(uint64_t value);
  15. void writeFloat(float value);
  16. void writeDouble(double value);
  1. void ByteArray::writeFint8(int8_t value)
  2. {
  3.     write(&value, sizeof(value));
  4. }
  6. void ByteArray::writeFuint8(uint8_t value)
  7. {
  8.     write(&value, sizeof(value));
  9. }
  11. void ByteArray::writeFint16(int16_t value)
  12. {
  13.     //如果当前字节序和本机字节序不符 需要swap
  14.     if(m_endian != KIT_BYTE_ORDER)
  15.         value = byteswap(value);
  17.     write(&value, sizeof(value));
  18. }
  20. void ByteArray::writeFuint16(uint16_t value)
  21. {
  22.     if(m_endian != KIT_BYTE_ORDER)
  23.         value = byteswap(value);
  25.     write(&value, sizeof(value));
  26. }
  29. void ByteArray::writeFint32(int32_t value)
  30. {
  31.     if(m_endian != KIT_BYTE_ORDER)
  32.         value = byteswap(value);
  34.     write(&value, sizeof(value));
  35. }
  38. void ByteArray::writeFuint32(uint32_t value)
  39. {
  40.     if(m_endian != KIT_BYTE_ORDER)
  41.         value = byteswap(value);
  43.     write(&value, sizeof(value));
  44. }
  47. void ByteArray::writeFint64(int64_t value)
  48. {
  49.     if(m_endian != KIT_BYTE_ORDER)
  50.         value = byteswap(value);
  52.     write(&value, sizeof(value));
  53. }
  56. void ByteArray::writeFuint64(uint64_t value)
  57. {
  58.     if(m_endian != KIT_BYTE_ORDER)
  59.         value = byteswap(value);
  61.     write(&value, sizeof(value));
  62. }
  64. void ByteArray::writeFloat(float value)
  65. {
  66.     uint32_t v;
  67.     memcpy(&v, &value, sizeof(value));
  68.     writeFuint32(v);
  69. }
  71. void ByteArray::writeDouble(double value)
  72. {
  73.     uint64_t v;
  74.     memcpy(&v, &value, sizeof(value));
  75.     writeFuint64(v);
  76. }

1.2.3.3 写入varint压缩编码数据 （难点）

  1. /*带varint压缩存储*/
  2. void writeInt32(int32_t value);
  3. void writeUint32(uint32_t value);
  4. void writeInt64(int64_t value);
  5. void writeUint64(uint64_t value);

1). writeUint32()/writeInt32()

功能：写入经过varint压缩编码的uint32_t型数据/int32_t型数据，处理时候避免负数压缩

  1. void ByteArray::writeUint32(uint32_t value)
  2. {
  3.     //uint32_t 压缩后1~5字节的大小
  4.     uint8_t temp[5];
  5.     uint8_t i = 0;
  7.     //varint编码 msp等于1 就认为数据还没读完
  8.     while(value >= 0x80)
  9.     {   
  10.         //取低7位 + msp==1 组成新的编码数据
  11.         temp[i++] = (value & 0x7F) | 0x80;
  12.         value >>= 7;
  13.     }
  15.     temp[i++] = value;
  17.     write(temp, i);
  18. }
  20. void ByteArray::writeInt32(int32_t value)
  21. {
  22.     writeUint32(EncodeZigzag32(value));
  23. }

2). writeUint64()/writeInt64()

功能：写入经过varint压缩编码的uint64_t型数据/int64_t型数据，处理时候避免负数压缩

  1. void ByteArray::writeUint64(uint64_t value)
  2. {
  3.     //uint64_t 压缩后1~10字节的大小
  4.     uint8_t temp[10];
  5.     uint8_t i = 0;
  6.     //varint编码 msp等于1 就认为数据还没读完
  7.     while(value >= 0x80)
  8.     {
  9.         //取低7位 + msp==1 组成新的编码数据
  10.         temp[i++] = (value & 0x7F) | 0x80;
  11.         value >>= 7;
  12.     }
  14.     temp[i++] = value;
  15.     write(temp, i);
  17. }
  19. void ByteArray::writeInt64(int64_t value)
  20. {
  21.     writeUint64(EncodeZigzag64(value));
  22. }

1.2.3.4 写入string字符串类型

  1. /**
  2.  * @brief 写入 长度:int16_t + 字符串数据
  3.  * @param value 传入的字符串
  4.  */
  5. void writeStringF16(const std::string& value);
  7. /**
  8.  * @brief 写入 长度:int32_t + 字符串数据
  9.  * @param value 传入的字符串
  10.  */
  11. void writeStringF32(const std::string& value);
  13. /**
  14.  * @brief 写入 长度:int64_t + 字符串数据
  15.  * @param value 传入的字符串
  16.  */
  17. void writeStringF64(const std::string& value);
  19. /**
  20.  * @brief 写入 长度:varint(变长) + 字符串数据
  21.  * @param value 传入的字符串
  22.  */
  23. void writeStringVint(const std::string& value);
  25. /**
  26.  * @brief 写入 不带长度字符串数据
  27.  * @param value 传入的字符串
  28.  */
  29. void writeStringWithoutLen(const std::string& value);
  1. void ByteArray::writeStringF16(const std::string& value)
  2. {
  3.     //先写入一个长度 在写入具体数据
  4.     writeFuint16(value.size());
  5.     write(value.c_str(), value.size());
  6. }
  8. void ByteArray::writeStringF32(const std::string& value)
  9. {
  10.     //先写入一个长度 在写入具体数据
  11.     writeFuint32(value.size());
  12.     write(value.c_str(), value.size());
  13. }
  15. void ByteArray::writeStringF64(const std::string& value)
  16. {
  17.     //先写入一个长度 在写入具体数据
  18.     writeFuint64(value.size());
  19.     write(value.c_str(), value.size());
  20. }
  22. void ByteArray::writeStringVint(const std::string& value)
  23. {
  24.     //写入压缩长度uint64_t型
  25.     writeUint64(value.size());
  26.     write(value.c_str(), value.size());
  27. }
  29. void ByteArray::writeStringWithoutLen(const std::string& value)
  30. {
  31.     write(value.c_str(), value.size());
  32. }

1.2.3.5 将内存内容写入到文件

功能：将当前内存结点保存的内容全部写入到文件中，且不改变当前的内存指针位置。

  1. /**
  2.  * @brief 将数据从内存写入到文件中
  3.  * @param[in] name 写入的文件路径
  4.  * @return true 写入成功
  5.  * @return false 写入失败
  6.  */
  7. bool writeToFile(const std::string& name) const;
  9. bool ByteArray::writeToFile(const std::string& name) const
  10. {
  11.     std::ofstream ofs;
  12.     //先清除内容再打开 以二进制方式写入
  13.     ofs.open(name, std::ios::trunc | std::ios::binary);
  14.     if(!ofs)
  15.     {
  16.         KIT_LOG_ERROR(g_logger) << "ByteArray::writeToFile open error, errno=" << errno << ", is:" 
  17.             << strerror(errno);
  19.         return false;
  20.     }
  22.     //获取剩余可读取的数据量
  23.     int64_t remain_size = getReadSize();
  24.     //拿到当前内存指针位置 作为一个副本
  25.     int64_t pos = m_position;
  26.     Node * cur = m_cur;
  27.     while(remain_size > 0)
  28.     {
  29.         //计算得到当前内存指针所处内存块的偏移量位置
  30.         int diff = pos % m_baseSize;
  32.         //计算能写入的长度 = min(剩余可读数据量, 单个结点容量) - 内存指针偏移量
  33.         int64_t len = (remain_size > (int64_t)m_baseSize ? m_baseSize : remain_size) - diff;
  35.         ofs.write(cur->ptr + diff, len);
  36.         cur = cur->next;
  37.         pos += len;
  38.         remain_size -= len;
  39.     }
  41.     return true;
  42. }

1.2.4 读系列函数

1.2.4.1 read()（核心）

功能：将内存块的内容读取到缓冲区中。和write()一模一样的流程，读什么位置依赖于内存指针的位置，始终从内存指针m_position一直读到最后

  1. /**
  2.  * @brief 将数据从内存读出
  3.  * @param[out] buf 读取缓冲区指针 
  4.  * @param[in] size 预计要读取的字节大小
  5.  */
  6. void read(char *buf, size_t size);
  8. void ByteArray::read(char *buf, size_t size)
  9. {
  10.     //读取的长度超出可读范围要抛异常
  11.     if(size > getReadSize())
  12.         throw std::out_of_range("memory pool not enough!!");
  14.     //内存指针现在在内存块结点哪一个字节位置上
  15.     size_t npos = m_position % m_baseSize;
  16.     //当前结点剩余容量
  17.     size_t ncap = m_cur->size - npos;
  18.     //当前已经读取的数据量
  19.     size_t bpos = 0;
  21.     while(size > 0)
  22.     {
  23.         if(ncap >= size)
  24.         {
  25.             memcpy(buf + bpos, m_cur->ptr + npos, size);
  26.             //如果当前结点被读完
  27.             if(m_cur->size == npos + size)
  28.                 m_cur = m_cur->next;
  30.             m_position += size;
  31.             bpos += size;
  32.             size = 0;            
  34.         }
  35.         else
  36.         {
  37.             memcpy(buf + bpos, m_cur->ptr + npos, ncap);
  38.             m_position += ncap;
  39.             bpos += ncap;
  40.             size -= ncap;
  41.             m_cur = m_cur->next;
  42.             npos = 0;
  43.         }
  45.     }
  46. }

1.2.4.2 （重载）read()（核心）

功能：将内存块的内容读取到缓冲区中，但不影响当前内存指针指向的位置，使用一个外部传入的内存指针position，而不使用当前真正的内存指针m_position。即：用户只关心存储的内容，而不关心是否移除内存中的内容，或许还要紧接着写入内容。

  1. /**
  2.  * @brief 将数据从内存读出 但不影响操作指针位置
  3.  * @param[out] buf 读取缓冲区指针 
  4.  * @param[in] size 预计要读取的字节大小
  5.  * @param[in] position 当前内存操作指针的位置
  6.  */
  7. void read(char *buf, size_t size, size_t position) const;

1.2.4.3 读取固定长度数据

除了1字节长度的数据，其他 >1字节的数据需要检查存储的数据字节序是否和用户物理机的字节序相同，不同需要进行字节序调整交换。（采用宏替换简化代码）

  1. /*固定长度读取*/
  2. int8_t      readFint8();
  3. uint8_t     readFuint8();
  4. int16_t     readFint16();
  5. uint16_t    readFuint16();
  6. int32_t     readFint32();
  7. uint32_t    readFuint32();
  8. int64_t     readFint64();
  9. uint64_t    readFuint64();
  11. float       readFloat();
  12. double      readDouble();
  1. int8_t ByteArray::readFint8()
  2. {
  3.     int8_t v;
  4.     read((char*)&v, sizeof(v));
  5.     return v;
  6. }
  9. uint8_t ByteArray::readFuint8()
  10. {
  11.     uint8_t v;
  12.     read((char*)&v, sizeof(v));
  13.     return v;
  14. }
  16. #define READ_XX(type)\
  17.     type v;\
  18.     read((char*)&v, sizeof(v));\
  19.     if(m_endian !=  KIT_BYTE_ORDER)\
  20.         v = byteswap(v);\
  21.     return v;
  24. int16_t ByteArray::readFint16()
  25. {
  26.     READ_XX(int16_t);
  27. }
  29. uint16_t ByteArray::readFuint16()
  30. {
  31.     READ_XX(uint16_t);
  32. }
  34. int32_t ByteArray:: readFint32()
  35. {
  36.     READ_XX(int32_t);
  37. }
  39. uint32_t ByteArray::readFuint32()
  40. {
  41.     READ_XX(uint32_t);
  42. }
  44. int64_t ByteArray::readFint64()
  45. {
  46.     READ_XX(int64_t);
  47. }
  49. uint64_t ByteArray::readFuint64()
  50. {
  51.     READ_XX(uint64_t);
  52. }
  54. float ByteArray::readFloat()
  55. {
  56.     uint32_t v = readUint32();
  57.     float value;
  58.     memcpy(&value, &v, sizeof(v));
  60.     return value;
  62. }
  64. double ByteArray::readDouble()
  65. {
  66.     uint64_t v = readUint64();
  67.     double value;
  68.     memcpy(&value, &v, sizeof(v));
  70.     return value;
  71. }

1.2.4.4 写入varint压缩编码数据 （难点）

  1. /*读取varint压缩后的数据*/
  2. int32_t     readInt32();
  3. uint32_t    readUint32();
  4. int64_t     readInt64();
  5. uint64_t    readUint64();

1). readUint32()/readInt32()

功能：读取经过varint压缩编码的uint32_t型数据/int32_t型数据，处理时候恢复出负数

  1. int32_t ByteArray::readInt32()
  2. {
  3.     return DecodeZigzag32(readUint32());
  4. }
  6. uint32_t ByteArray::readUint32()
  7. {
  8.     //最终得到一个uint32_t型数据
  9.     uint32_t result = 0;
  10.     //读取次数 = 32 / 7 + 1 组
  11.     for(int i = 0;i < 32;i += 7)
  12.     {
  13.         //一次读取8位
  14.         uint8_t b = readFuint8();
  15.         //msp==0 说明这是该数据的最后一个字节
  16.         if(b < 0x80)
  17.         {
  18.             //把取出来的位恢复到原来对应的位上
  19.             result |= ((uint32_t)b) << i;
  20.             break;
  21.         }
  22.         else    //msp==1 说明后面还有字节没有取 要去掉头部的msp位
  23.             result |= ((uint32_t)(b & 0x7F)) << i;
  24.     }
  26.     return result;
  27. }

2). readUint64()/readInt64()

功能：读取经过varint压缩编码的uint64_t型数据/int64_t型数据，处理时候恢复出负数

  1. int64_t ByteArray::readInt64()
  2. {
  3.     return DecodeZigzag64(readUint64());
  4. }
  6. uint64_t ByteArray::readUint64()
  7. {
  8.     //最终得到一个uint32_t型数据
  9.     uint64_t result = 0;
  10.     //读取次数 = 64 / 7 + 1 组
  11.     for(int i = 0;i < 64;i += 7)
  12.     {
  13.         uint8_t b = readFuint8();
  14.         //msp==0 说明这是该数据的最后一个字节
  15.         if(b < 0x80)
  16.         {
  17.             //最后一个字节直接或运算 不用去msp位
  18.             result |= ((uint64_t)b) << i;
  19.             break;
  20.         }
  21.         else    //msp==1 说明后面还有字节没有取 要去掉头部的msp位
  22.             result |= ((uint64_t)(b & 0x7F)) << i;
  23.     }
  25.     return result;
  26. }

1.2.4.5 读取string字符串类型

  1. /**
  2.  * @brief 读取 长度:int16_t + 字符串数据
  3.  * @return std::string 
  4.  */
  5. std::string     readStringF16();
  7. /**
  8.  * @brief 读取 长度:int32_t + 字符串数据
  9.  * @return std::string 
  10.  */
  11. std::string     readStringF32();
  13. /**
  14.  * @brief 读取 长度:int64_t + 字符串数据
  15.  * @return std::string 
  16.  */
  17. std::string     readStringF64();
  19. /**
  20.  * @brief 读取 长度:varint(变长) + 字符串数据
  21.  * @return std::string 
  22.  */
  23. std::string     readStringVint();
  1. std::string ByteArray::readStringF16()
  2. {
  3.     uint16_t len = readFuint16();
  4.     std::string buf;
  5.     buf.resize(len);
  6.     read(&buf[0], len);
  7.     return buf;
  8. }
  10. std::string ByteArray::readStringF32()
  11. {
  12.     uint32_t len = readFuint32();
  13.     std::string buf;
  14.     buf.resize(len);
  15.     read(&buf[0], len);
  16.     return buf;
  17. }
  19. std::string ByteArray::readStringF64()
  20. {
  21.     uint64_t len = readFuint64();
  22.     std::string buf;
  23.     buf.resize(len);
  24.     read(&buf[0], len);
  25.     return buf;
  26. }
  28. std::string ByteArray::readStringVint()
  29. {
  30.     uint64_t len = readUint64();
  31.     std::string buf;
  32.     buf.resize(len);
  33.     read(&buf[0], len);
  34.     return buf;
  35. }

1.2.4.6 将文件内容读取到内存中

  1. /**
  2.  * @brief 将数据从文件中读取到内存中
  3.  * @param[in] name 读取的文件路径
  4.  * @return true 读取成功
  5.  * @return false 读取失败
  6.  */
  7. bool readFromFile(const std::string& name);
  9. bool ByteArray::readFromFile(const std::string& name)
  10. {
  11.     std::ifstream ifs;
  12.     //以二进制打开
  13.     ifs.open(name, std::ios::binary);
  14.     if(!ifs)
  15.     {
  16.         KIT_LOG_ERROR(g_logger) << "ByteArray::readFromFile open error, errno=" << errno << ", is:" 
  17.             << strerror(errno);
  19.         return false;
  20.     }
  22.     //用智能指针定义一个char数组 指定析构函数释放该空间
  23.     std::shared_ptr<char> buf(new char[m_baseSize], [](char *ptr){ 
  24.         delete[] ptr;
  25.     });
  27.     while(!ifs.eof())   //没有到文件末尾就一直读入
  28.     {
  29.         //从文件读取到buf 每次读取一个结点大小的数据量
  30.         ifs.read(buf.get(), m_baseSize);
  31.         //从buf写回到内存池  gcount()是真正的从文件读取到的长度
  32.         write(buf.get(), ifs.gcount());
  34.     }
  36.     return true;
  38. }

1.2.5 setPosition()/getPosition()

功能：设置/获取当前操作内存指针的位置

  1. /**
  2.  * @brief 获取当前操作内存指针的位置
  3.  * @return size_t 返回位置坐标数值
  4.  */
  5. size_t getPosition() const {return m_position;}
  7. /**
  8.  * @brief 设置当前操作内存指针的位置
  9.  * @param[in] val 传入准备设置的指针位置数值
  10.  */
  11. void setPosition(size_t val); 
  13. //设定内存位置
  14. void ByteArray::setPosition(size_t val)
  15. {
  16.     //设置内存指针位置超出了当前总容量大小 抛出异常
  17.     if(val > m_capacity)
  18.         throw std::out_of_range("set position out of range");
  20.     m_position = val;
  21.     //检查内存指针位置 > 使用内存空间大小要进行更新 
  22.     m_size = m_position > m_size ? m_position : m_size;
  23.     m_cur = m_root;
  25.     /*移动当前可用结点指针m_cur*/
  26.     //只要设定值val比单个结点容量大小大 认为没达到预期设定位置
  27.     while(val >= m_cur->size)
  28.     {
  29.         val -= m_cur->size;
  30.         m_cur = m_cur->next;
  31.     }
  34. }

1.2.6 clear()

功能：清除当前内存结点中所有内容

  1. /**
  2.  * @brief 清除当前内存结点中所有内容
  3.  */
  4. void clear();
  6. void ByteArray::clear()
  7. {
  8.     m_position = m_size = 0;
  9.     //只留下一个结点 其他结点全部清理
  10.     m_capacity = m_baseSize;    
  11.     Node* temp = m_root->next;
  12.     while(temp)
  13.     {
  14.         m_cur = temp;
  15.         temp = temp->next;
  16.         delete m_cur;
  17.     }
  18.     m_cur = m_root;
  19.     m_root->next = nullptr;
  20. }

1.2.7 getBaseSize()

功能：获取单个结点容量

  1. /**
  2.  * @brief 获取内存单个结点存储容量大小
  3.  * @return size_t 
  4.  */
  5. size_t getBaseSize() const {return m_baseSize;};

1.2.8 getReadSize()

功能：获取剩余可读数据容量

  1. /**
  2.  * @brief 获取当前内存中剩余可读数据的容量
  3.  * @return size_t 
  4.  */
  5. size_t getReadSize() const {return m_size - m_position;}

1.2.9 getSize()

功能：获取当前整个内存已经使用的空间大小

  1. /**
  2.  * @brief 获取当前整个内存已经使用的空间大小
  3.  * @return size_t 
  4.  */
  5. size_t getSize() const {return m_size;}

1.2.10 toString()/toHexString()

功能：将内存块的内容输出为可显示文本/十六进制文本

  1. /**
  2.  * @brief 将内存块的内容输出为可显示文本
  3.  * @return std::string 
  4.  */
  5. std::string toString() const;
  7. /**
  8.  * @brief 将内存块的内容输出为十六进制文本
  9.  * @return std::string 
  10.  */
  11. std::string toHexString() const;
  13. std::string ByteArray::toString() const
  14. {
  15.     std::string s;
  16.     s.resize(getReadSize());
  17.     if(!s.size())
  18.         return s;
  20.     //不影响内存指针位置 仅仅是显示
  21.     read(&s[0], s.size(), m_position);
  23.     return s;
  24. }
  26. std::string ByteArray::toHexString() const 
  27. {
  28.     std::string s = toString();
  29.     std::stringstream ss;
  31.     for(size_t i = 0;i < s.size();++i)
  32.     {
  33.         //一行显示32个字符
  34.         if(i > 0 && i % 32 == 0)
  35.             ss << std::endl;
  37.         //一次显示一个字节 2个字符，不足的要用0补齐
  38.         ss << std::setw(2) << std::setfill('0') << std::hex
  39.             << (int)(uint8_t)s[i] << " ";
  40.     }
  42.     return ss.str();
  44. }

1.2.11 getReadBuf()

功能：把内存中所有可读部分拿到用户缓冲区中去，从当前内存指针位置开始。从ByteArray中读取数据

  1. /**
  2.  * @brief 把内存中所有可读部分拿到用户缓冲区中去,从当前位置开始
  3.  * @param[out] buffers 存储内存内容的缓冲区
  4.  * @param[in] len 准备读取的长度
  5.  * @return uint64_t 返回实际读取字节数 
  6.  */
  7. uint64_t getReadBuf(std::vector<struct iovec>& buffers, uint64_t len) const;
  9. uint64_t ByteArray::getReadBuf(std::vector<struct iovec>& buffers, uint64_t len) const
  10. {
  11.     len = len > getReadSize() ? getReadSize() : len;
  12.     if(len == 0)
  13.         return 0;
  15.     uint64_t size = len;
  17.     size_t npos = m_position % m_baseSize;
  18.     size_t ncap = m_cur->size - npos;
  20.     Node* cur = m_cur;
  21.     while(len > 0)
  22.     {
  23.         struct iovec iov;
  24.         //当前结点剩余容量大小 > 读取的长度
  25.         if(ncap > len)
  26.         {
  27.             iov.iov_base = cur->ptr + npos;
  28.             iov.iov_len = len;
  29.             len = 0;
  30.         }
  31.         else // 当前结点剩余容量大小 <= 读取的长度
  32.         {
  33.             iov.iov_base = cur->ptr + npos;
  34.             iov.iov_len = ncap;
  35.             len -= ncap;
  37.             cur = cur->next;
  38.             ncap = cur->size;
  39.             npos = 0;
  40.         }
  42.         buffers.push_back(iov);
  43.     }
  45.     return size;
  46. }

1.2.12 (重载)getReadBuf()

功能：把内存中所有可读部分拿到用户缓冲区中去，从指定内存指针位置开始。从ByteArray中读取数据

  1. /**
  2.  * @brief 把内存中所有可读部分拿到用户缓冲区中去,从指定位置开始
  3.  * @param[out] buffers 存储内存内容的缓冲区
  4.  * @param[in] len 准备读取的长度
  5.  * @param[in] position 指定读取开始位置
  6.  * @return uint64_t 返回实际读取字节数 
  7.  */
  8. uint64_t getReadBuf(std::vector<struct iovec>& buffers, uint64_t len, uint64_t position) const;
  11. uint64_t ByteArray::getReadBuf(std::vector<struct iovec>& buffers, uint64_t len, uint64_t position) const
  12. {
  13.     len = len > getReadSize() ? getReadSize() : len;
  14.     if(len == 0)
  15.         return 0;
  17.     uint64_t size = len;
  19.     size_t npos = position % m_baseSize;
  21.     //找到指定位置所在的内存节点
  22.     size_t count = position / m_baseSize;
  23.     Node* cur = m_root;
  24.     while(count > 0)
  25.     {
  26.         cur = cur->next;
  27.         --count;
  28.     }
  30.     size_t ncap = cur->size - npos;
  33.     while(len > 0)
  34.     {
  35.         struct iovec iov;
  36.         if(ncap > len)
  37.         {
  38.             iov.iov_base = cur->ptr + npos;
  39.             iov.iov_len = len;
  40.             len = 0;
  41.         }
  42.         else
  43.         {
  44.             iov.iov_base = cur->ptr + npos;
  45.             iov.iov_len = ncap;
  46.             len -= ncap;
  47.             cur = cur->next;
  48.             ncap = cur->size;
  49.             npos = 0;
  50.         }
  52.         buffers.push_back(iov);
  53.     }
  55.     return size;
  56. }

1.2.13 getWriteBuf()

功能：把内存中所有可写部分拿到用户缓冲区中去，从指定内存指针位置开始。向ByteArray中写入数据

/**
 * @brief 把内存中所有可写部分拿到用户缓冲区中去,从指定位置开始
 * @param[out] buffers 存储内存内容的缓冲区
 * @param[in] len 准备读取的长度
 * @return uint64_t 返回实际读取字节数 
 */
uint64_t getWriteBuf(std::vector<struct iovec>& buffers, uint64_t len);

uint64_t ByteArray::getWriteBuf(std::vector<struct iovec>& buffers, uint64_t len)
{
    if(len == 0)
        return 0;

    //写入前先扩展容量
    addCapacity(len);
    size_t size = len;

    size_t npos = m_position % m_baseSize;
    size_t ncap = m_cur->size - npos;
    struct iovec iov;
    Node *cur = m_cur;
    while(len > 0)
    {
        if(ncap >= len)
        {
            iov.iov_base = cur->ptr + npos;
            iov.iov_len = len;
            len = 0;
        }
        else
        {
            iov.iov_base = cur->ptr + npos;
            iov.iov_len = ncap;

            len -= ncap;
            cur = cur->next;
            npos = 0;
            ncap = cur->size;
        }

        buffers.push_back(iov);
    }

    return size;
}

C\C++知识点复习补充：float、double类型存储结构

概念：C\C++中对float数据使用32位存储，double数据使用64位存储。

组成部分 = 符号位 + 指数位 + 尾数位

  • 符号位：0为正数，1为负数
  • 指数位：存储科学计数法中的指数部分，采用移位存储
  • 尾数位：存储尾数

float = 1 bit + 8 bit + 23 bit
double = 1 bit + 11 bit + 52 bit

数据序列化与反序列化开发 - 图1

例子

  • float = 9.125 ，科学记数法表示为 9.125 * 10^0
    9.125 = 9 + 0.125 = 1001 | 0.001
1001.001 使用科学记数法表示：1.001001 * 2^3
    那么001001称为尾数部分，3称为指数位。由于1.任何时候都不会改变因此不用存储，这使得float的23bit的尾数可以表示24bit的精度，double中52bit的尾数可以表达53bit的精度。

注意：存储指数位时采用移位存储，即：基数开始不为0，而是127。指数位最终存储结果：1000 0010

  • 最终存储结果：

数据序列化与反序列化开发 - 图2

对于float、double精度位数不同来源于尾数位

十进制中最高位 9 = 1001，也就是1位十进制需要4位二进制表示
float精度 = 24 / 4 = 6位
double精度 = 53 / 4= 13位
由于保存精度有限，因此使用float、double保存金额等数据是不安全的，造成精度丢失。小数转化为二进制的时候可能出现无限循环的可能，最终表示的尾数位只能截断。