序列化和反序列化一 --- rpc学习

1 什么是序列化反序列化

序列化(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

常用的protobuf:

        序列化：将数据结构或对象转换成二进制串的过程。
        反序列化：将在序列化过程中所产生的二进制串转换成数据结构或对象的过程。

2 序列化的方式

1.文本格式：JSON、XMLI
 2.二进制格式：protobuf

3 内存表示

先理解：

什么是指针，指针是存放地址的变量。 什么是地址，地址就是内存编号。 什么是内存，就是便于访问的存储空间。

#include <stdio.h>
#include <iostream>

int main() {
    int i = 42;
    //地址转为char*  int为4字节
    char* ptr = (char*)&i;
    int temp = *((int32_t*)ptr);

    for(size_t j = 0; j < sizeof(int); ++j) {
        printf("%02x ", (unsigned char)ptr[j]);
    }

    std::cout << temp <<std::endl;
   
    return 0;
}

输出：

2a 00 00 00//输出一个整数（在这里是42）的内存表示 
42

 

4 简单的二进制序列实现

#pragma once

#include <iostream>
#include <string.h>
#include <vector>
#include <cstring>


namespace yazi{
namespace serialize{

class DataStream{
public:
    //数据类型
    enum DataType{
        BOOL =0,
        CHAR,INT32,
        INT64,
        FLOAT,
        DOUBLE,
        STRING,
        VECTOR,
        LIST,
        MAP,
        SET,
        CUSTOM
    };
    DataStream():m_pos(0){}
    ~DataStream(){}

    void write(const char* data,int len);
    void write(bool value);
    void write(char value);
    void write(int32_t value);
    void write(int64_t value);
    void write(float value);
    void write(double value);
    void write(const char* value);
    void write(const std::string& value);

    void show() const;

    template<typename T> 
    DataStream& operator<<(T value){
        write(value);
        return *this;
    }

    bool read(bool& value);
    bool read(char& value);
    bool read(int32_t& value);
    bool read(int64_t& value);
    bool read(float& value);
    bool read(double& value);
    bool read(std::string& value);

    template<typename T> 
    DataStream& operator>>(T& value){
        read(value);
        return *this;
    }


private:
    void reserve(int len);

private:
    std::vector<char> m_buf;
    int m_pos;
};

//vector的扩容
void DataStream::reserve(int len){
    int size = m_buf.size();
    int cap = m_buf.capacity();
    if(size+len > cap){
        //vector扩容
        while(size+len>cap){
            if(cap == 0){
                cap=1;
            }else{
                cap*=2;
            }
        }
        m_buf.reserve(cap);
    }
}

void DataStream::write(const char* data,int len){
    reserve(len);
    int size = m_buf.size();
    m_buf.resize(size+len);
    memcpy(&m_buf[size],data,len);
}

void DataStream::write(bool value){
    char type = DataType::BOOL;
    write((char *)&type,sizeof(char));
    //将指向value的地址转化为char*类型的存贮
    write((char *)&value,sizeof(char));
}

void DataStream::write(char value){
    char type = DataType::CHAR;
    write((char *)&type,sizeof(char));
    write((char *)&value,sizeof(char));
}

void DataStream::write(int32_t value){
    char type = DataType::INT32;
    write((char *)&type,sizeof(char));
    write((char *)&value,sizeof(int32_t));
}

void DataStream::write(int64_t value){
    char type = DataType::INT64;
    write((char *)&type,sizeof(char));
    write((char *)&value,sizeof(int64_t));
}

void DataStream::write(float value){
    char type = DataType::FLOAT;
    write((char *)&type,sizeof(char));
    write((char *)&value,sizeof(float));
}

void DataStream::write(double value){
    char type = DataType::DOUBLE;
    write((char *)&type,sizeof(char));
    write((char *)&value,sizeof(double));
}

void DataStream::write(const char* value){
    char type = DataType::STRING;
    write((char *)&type,sizeof(char));
    int len = strlen(value);
    write(len);
    write(value,len);
}

void DataStream::write(const std::string& value){
    char type = DataType::STRING;
    write((char *)&type,sizeof(char));
    int len = value.size();
    write(len);
    write(value.data(),len);
}

bool DataStream::read(bool& value){
    if(m_buf[m_pos]!=DataType::BOOL){
        return false;
    }
    ++m_pos;
    value = m_buf[m_pos];
    ++m_pos;
    return true;
}

bool DataStream::read(char& value){
    if(m_buf[m_pos]!=DataType::CHAR){
        return false;
    }
    ++m_pos;
    value = m_buf[m_pos];
    ++m_pos;
    return true;
}

bool DataStream::read(int32_t& value){
    if(m_buf[m_pos]!=DataType::INT32){
        return false;
    }
    ++m_pos;
    value = *((int32_t*)(&m_buf[m_pos]));
    m_pos+=4;
    return true;
}

bool DataStream::read(int64_t& value){
    if(m_buf[m_pos]!=DataType::INT64){
        return false;
    }
    ++m_pos;
    value = *((int64_t*)(&m_buf[m_pos]));
    m_pos+=8;
    return true;
}

bool DataStream::read(float& value){
    if(m_buf[m_pos]!=DataType::FLOAT){
        return false;
    }
    ++m_pos;
    value = *((float*)(&m_buf[m_pos]));
    m_pos+=4;
    return true;
}

bool DataStream::read(double& value){
    if(m_buf[m_pos]!=DataType::DOUBLE){
        return false;
    }
    ++m_pos;
    value = *((double*)(&m_buf[m_pos]));
    m_pos+=8;
    return true;
}

bool DataStream::read(std::string & value){
    if(m_buf[m_pos]!=DataType::STRING){
        return false;
    }
    ++m_pos;
    int len;
    read(len);
    if(len<0) return false;

    value.assign((char *)&(m_buf[m_pos]),len);
    m_pos+=len;
    return true;
}

     
}
    
}

main.cpp 

#include <iostream>

#include "DataStream.h"

int main(){
    yazi::serialize::DataStream ds;
    //序列化
    ds << true<<1.2<<"asd";
    bool a;
    double b;
    std::string c;
    //反序列化
    ds >> a>>b>>c;
    std::cout << a<<"\n"<<b<<"\n"<<c<<std::endl;
    return 0;
}

输出

1
1.2
asd