字节编码

#include<stdio.h>
#include <string>
using namespace std;
class Student{
public:
int id;
string name;
};//定义一个普通类
int Sequence(const Student &s,char output[]){
//序列化
int count=0;//定义序列长度
memcpy(output,&s.id,4);//将id存入output数组，长度为4
count+=4;//count加4
memcpy(output+count,s.name.c_str(),s.name.length());
//然后将string类型的对象转化为c风格字符串，再放入字符串
count+=s.name.length();
return count;//返回总长度

}
int DeSequence(Student &s,const char *input ,int count){
//反序列化
int offset=0;//控制长度
memcpy(&s.id,input,4);//拷贝4个字节到s.id中
offset+=4;//增加长度
s.name.append((char *)input+4,count-offset);
//而字符串的添加需要换一种格式。（char-》string类型）
return 0;

}
int main(){
char buf[128];
int count =0;

if(1){
Student s;
s.id=8;
s.name="张三";
count=Sequence(s,buf);

}
if(1){
Student s2;
DeSequence(s2,buf,count);
}

return 0;
}

#include <stdio.h>
#include <string.h>

int toBytes(unsigned int a, unsigned char* buf)
{//将整型转换为字节
buf[0] = a >> 24;
buf[1] = a >> 16;
buf[2] = a >> 8;
buf[3] = a;
return 4;
}

unsigned int fromBytes(const unsigned char* buf)
{//将字节转换成整型
unsigned int result = 0;
result += buf[0] << 24;
result += buf[1] << 16;
result += buf[2] << 8;
result += buf[3];
return result;
}

int main()
{
unsigned int abc = 0x12345678;

unsigned char buf[4];
//转化为字节型,小端
toBytes(abc, buf);
//将其转化为unsigned int型
unsigned int b = fromBytes(buf);
return 0;
}

#include <stdio.h>
#include <string.h>

#include <string>
using std::string;

class AfByteBuffer//字节编码器
{
public:
AfByteBuffer(int size)
{//构造函数
m_buffer = new char[size];//初始化大小
m_offset = 0;
m_length = size;
m_owner = true;

m_start = (unsigned char*)m_buffer + m_offset;
m_written = 0; // 写计数
m_read = 0; // 读计数
}
AfByteBuffer(char* buf, int off, int length)
{
m_buffer = buf;
m_offset = off;
m_length = length;
m_owner = false;

m_start = (unsigned char*)m_buffer + m_offset;
m_written = 0; // 写计数
m_read = 0; // 读计数
}

~AfByteBuffer()
{
if(m_owner && m_buffer)
{
delete [] m_buffer;
}
}

unsigned char* start()
{
return m_start;
}
int sizeWritten()
{
return m_written;
}
int sizeRead() const
{
return m_read;
}

////////////////////////////////////////
void putUint8(unsigned char val)
{
unsigned char* p = m_start + m_written;
p[0] = val;
m_written += 1;
}
void putUint16(unsigned short val)
{
unsigned char* p = m_start + m_written;
p[0] = val>>8;
p[1] = val;
m_written += 2;
}
void putUint32(unsigned int val)
{
unsigned char* p = m_start + m_written;
p[0] = val>>24;
p[1] = val>>16;
p[2] = val>>8;
p[3] = val;
m_written += 4;
}
void putUint64(unsigned long long val)
{
unsigned char* p = m_start + m_written;
p[0] = val>>56;
p[1] = val>>48;
p[2] = val>>40;
p[3] = val>>32;
p[4] = val>>24;
p[5] = val>>16;
p[6] = val>>8;
p[7] = val;
m_written += 8;
}
void putString(const string& val)
{
unsigned short length = val.length();
putUint16(length);

unsigned char* p = m_start + m_written;
memcpy(p, val.c_str(), length);
m_written += length;
}

void putBytes(const char* data, int length)
{
putUint16(length);

unsigned char* p = m_start + m_written;
memcpy(p, data, length);
m_written += length;
}

/////////////////////////////////////////
unsigned char getUint8()
{
unsigned char* p = m_start + m_read;
unsigned char result = p[0];
m_read += 1;
return result;
}
unsigned short getUint16()
{
unsigned char* p = m_start + m_read;
unsigned short result = p[0];
result = (result<<8) + p[1];
m_read += 2;
return result;
}
unsigned int getUint32()
{
unsigned char* p = m_start + m_read;
unsigned char result = p[0];
result = (result<<8) + p[1];
result = (result<<8) + p[2];
result = (result<<8) + p[3];
m_read += 4;
return result;
}
unsigned long long getUint64()
{
unsigned char* p = m_start + m_read;
unsigned char result = p[0];
result = (result<<8) + p[1];
result = (result<<8) + p[2];
result = (result<<8) + p[3];
result = (result<<8) + p[4];
result = (result<<8) + p[5];
result = (result<<8) + p[6];
result = (result<<8) + p[7];
m_read += 8;
return result;
}
string getString()
{
unsigned short length = getUint16();

unsigned char* p = m_start + m_read;
string result;
result.append((char*)p, length);
m_read+= length;

return result;
}

// string类也可以放“不以0结束的无规则数据”
int getBytes(char* buf, int maxsize)
{
unsigned short length = getUint16();

unsigned char* p = m_start + m_read;
memcpy(buf, p, length);
return length;
}

private:
char* m_buffer;
int   m_offset;
int   m_length;
bool  m_owner;

unsigned char* m_start;
int   m_written; // 已经写入的数据个数
int   m_read;    // 已经读取的数据个数
};

include <stdio.h>
#include "AfByteBuffer.h"

/* STL support */
#include <string>
using namespace std;

class Student
{
public:
int id;
string name;
};

int main()
{
char buf[128];
int count = 0;

if(1)
{//序列化
Student s1;
s1.id = 123;
s1.name = "shaofa";

AfByteBuffer enc(buf, 0, 128);
enc.putUint32(s1.id);
enc.putString(s1.name);
count = enc.sizeWritten();
}

if(1)
{//反序列化
Student s2;

AfByteBuffer dec(buf, 0, count);
s2.id = dec.getUint32();
s2.name = dec.getString();

}

if(1)
{
Student s1;
s1.id = 123;
s1.name = "shaofa";

AfByteBuffer enc(512);
enc.putUint32(s1.id);
enc.putString(s1.name);
unsigned char* ptr = enc.start();
int n = enc.sizeWritten();

}

return 0;
}