string、vector和map的序列化和反序列化

最近在做序列化和反序列化的学习，在此记录一下，以后写了新的数据类型再加进来。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include<fstream>
#include<vector>
#include<map>
#include<list>
#include<random>
#include<mutex>
#include<thread>
#pragma comment(lib,"ws2_32.lib")

using namespace  std;

void serialize(char *sendBuf, const string & str, int &step);
void deserialize(string & str, const char *recvBuf, int &step);




//对于基础类型的序列化
//Det:sendBuf的首地址
//Src：简单数据类型的地址
//size：数据类型的长度
//step：写的时候的偏移量
/********int************/
void serialize(char  *Det,const int * Src ,int &step)
{
	memcpy(Det + step, Src, sizeof(int));
	step += sizeof(int);
}

//对于基础类型的反序列化
//Det:解析出来后要存放的位置的首地址
//Src：recvBuf的首地址
//step：写的时候的偏移量
void deserialize(int * Det, const char *Src, int &step)
{
	memcpy(Det, Src + step, sizeof(int));
	step += sizeof(int);
}
/********char************/
void serialize(char  *Det, const char * Src, int &step)
{
	memcpy(Det + step, Src, sizeof(int));
	step += sizeof(int);
}
void deserialize(char * Det, const char *Src, int &step)
{
	memcpy(Det, Src + step, sizeof(int));
	step += sizeof(int);
}
/********long************/
void serialize(char  *Det, const long * Src, int &step)
{
	memcpy(Det + step, Src, sizeof(int));
	step += sizeof(int);
}
void deserialize(long * Det, const char *Src, int &step)
{
	memcpy(Det, Src + step, sizeof(int));
	step += sizeof(int);
}
/********double************/
void serialize(char  *Det, const double * Src, int &step)
{
	memcpy(Det + step, Src, sizeof(int));
	step += sizeof(int);
}
void deserialize(double * Det, const char *Src, int &step)
{
	memcpy(Det, Src + step, sizeof(int));
	step += sizeof(int);
}
/********float************/
void serialize(char  *Det, const float * Src, int &step)
{
	memcpy(Det + step, Src, sizeof(int));
	step += sizeof(int);
}
void deserialize(float * Det, const char *Src, int &step)
{
	memcpy(Det, Src + step, sizeof(int));
	step += sizeof(int);
}
//vector的序列化和反序列化，可以兼容任何简单类型
/********vector<long>************/
void serialize(char *sendBuf,const vector<long> &vec,int &step)
{
	//前面写了整个vector的长度，也写了vector中包含的数据
	int size=vec.size();
	serialize(sendBuf , &size, step);
	memcpy(sendBuf + step, &vec[0], size*sizeof(long));
	step += size*sizeof(long);
}

void deserialize(vector<long> &vec, const char *recvBuf, int &step)
{
	int size;
	deserialize(&size, recvBuf , step);
	//memcpy()
	vec.resize(size);
	memcpy(&vec[0], recvBuf, size*sizeof(long));
	step += size*sizeof(long);
}
/********vector<int>************/
void serialize(char *sendBuf, const vector<int> &vec, int &step)
{
	//前面写了整个vector的长度，也写了vector中包含的数据
	int size = vec.size();
	serialize(sendBuf, &size, step);
	memcpy(sendBuf + step, &vec[0], size*sizeof(int));
	step += size*sizeof(int);
}

void deserialize(vector<int> &vec, const char *recvBuf, int &step)
{
	int size;
	deserialize(&size, recvBuf, step);
	//memcpy()
	vec.resize(size);
	memcpy(&vec[0], recvBuf, size*sizeof(int));
	step += size*sizeof(int);
}
/********vector<string>************/
void serialize(char *sendBuf, const vector<string> &vec, int &step)
{
	//前面写了整个vector的长度，也写了vector中包含的数据
	int size = vec.size();
	serialize(sendBuf, &size, step);

	for (vector<string>::const_iterator it = vec.begin(); it != vec.end(); it++)
	{
		serialize(sendBuf,*it,step);
	}
	
}

void deserialize(vector<string> &vec, const char *recvBuf, int &step)
{
	int size;
	deserialize(&size, recvBuf, step);
	//memcpy()
	//vec.resize(size);
	string str;
	for (int i = 0; i < size; i++)
    {
		deserialize(str, recvBuf, step);
		vec.insert(vec.end(),str);
	}
	
}
//string  序列化和反序列化
void serialize(char *sendBuf,const string & str,int &step)
{
	int size;
	size = str.length();
	serialize(sendBuf,&size,step);
	memcpy(sendBuf + step, &str[0], size);
	step += size;
}

void deserialize(string & str,const char *recvBuf,int &step)
{
	
	int size;
	deserialize(&size, recvBuf, step);
	str = string(recvBuf + step, size);//用构造函数生成临时变量，然后进行赋值
	step += size;
}
/*
map的参数类型变化较大，暂且写<int,string>
*/
void serialize(char * sendBuf,map<int,string> &m,int &step)
{
	int size = m.size();
	serialize(sendBuf,&size,step);//size
	
	for (map<int, string>::iterator it= m.begin(); it != m.end(); it++)
	{
		serialize(sendBuf, &(it->first),step);
		serialize(sendBuf, it->second, step);
	}
	
}

void deserialize(map<int,string> &m,const char *recvBuf,int &step)
{
	int size;
	deserialize(&size, recvBuf, step);
	int int_first;
	string str_second;
	for (int i = 0; i < size; i++)
	{
		deserialize(&int_first, recvBuf, step);
		deserialize(str_second, recvBuf, step);
		m.insert(pair<int, string>(int_first, str_second));
	}
}
//自定义一个稍复杂的数据结构
typedef struct person
{
	int attribute;
	string name;
	map<int, string> friends;
	vector<long> experience;
}person;

void serialize_person(char *sendBuf,person &per,int &step)
{
	serialize(sendBuf, &per.attribute,  step);
	serialize(sendBuf, per.name, step);
	serialize(sendBuf, per.friends, step);
	serialize(sendBuf, per.experience, step);
}
void deserialize_person(person &per,char *recvBuf,int &step)
{
	deserialize(&per.attribute,recvBuf, step);
	deserialize( per.name,recvBuf, step);
	deserialize(per.friends,recvBuf, step);
	deserialize( per.experience, recvBuf,step);
}

//自定义的解析结构体的接口
void deserialize(char *recvBuf,person &per,int& step)
{
	int attribute;
	int temp_step = step;//此处解析后悔改变step的值，所以用一个临时值传进去。
	deserialize(&attribute,recvBuf,temp_step);
	switch (attribute)
	{
	case 100:
	{
				//person per;
				deserialize_person(per, recvBuf, step);
				
				cout <<endl<< "收到attribute为100的结构体后作出操作" << endl;
				break;
	}
	default:
		break;
	}

}


void main()
{
	//string类型
	char *sendBuf, *recvBuf;
	sendBuf = new char[1024];
	recvBuf = new char[1024];
	int step;
	string str="aaassddddddddddaaaaaaaaaaadsdddf";
	string str2;

	step = 0;
	serialize(sendBuf, str, step);

	memcpy(recvBuf, sendBuf, 1024);

	step = 0;
	deserialize(str2, recvBuf, step);
	
	cout << str2 << endl;



	//vector
	vector<int > vec = { 97, 98, 99 ,100,101};
	vector<int> vec2;
	
	sendBuf = new char[1024];
	recvBuf = new char[1024];

	step = 0;
	serialize(sendBuf, vec, step);

	memcpy(recvBuf, sendBuf, 1024);

	step = 0;
	deserialize(vec2, recvBuf, step);
	for (vector<int>::iterator it = vec2.begin(); it != vec2.end(); it++)
	{
		cout << *it << " " << endl;
	}
	//vector<string>

	vector<string> vec3;
	vector<string> vec4;
	vec3.insert(vec3.end(),"aaa");
	vec3.insert(vec3.begin(), "bbbb");
	vec3.insert(vec3.end(), "ccccc");
	vec3.insert(vec3.begin(), "dddddd");

	sendBuf = new char[1024];
	recvBuf = new char[1024];
	step = 0;
	serialize(sendBuf,vec3,step);
	memcpy(recvBuf, sendBuf, 1024);
	step = 0;
	deserialize(vec4,recvBuf,step);
	for (vector<string>::iterator it = vec3.begin(); it != vec3.end(); it++)
	{
		cout << *it << " " << endl;
	}
	for (vector<string>::iterator it = vec4.begin(); it != vec4.end(); it++)
	{
		cout << *it << " " << endl;
	}


	//map暂时只写了<int,string>的类型
	map<int, string>m = { pair<int, string>(1, "chen"), pair<int, string>(2, "bi"), pair<int, string>(3, "yun"), pair<int, string>(4, ",hi!") };
	for (map<int, string>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "<" << it->first << "," << it->second << ">" << endl;
	}

	map<int, string>m2;
	sendBuf = new char[1024];
	recvBuf = new char[1024];

	step = 0;
	serialize(sendBuf, m, step);

	memcpy(recvBuf, sendBuf, 1024);

	step = 0;
	deserialize(m2, recvBuf, step);
	for (map<int, string>::iterator it = m2.begin(); it != m2.end(); it++)
	{
		cout << "<" << it->first << "," << it->second << ">" << endl;
	}

	/********************************************/
	//person
	person per,per2;
	per.attribute = 100;
	per.name = "chenbiyun";
	per.friends.insert(pair<int, string>(102, "wancheng"));
	per.friends.insert(pair<int, string>(103, "chendudu"));
	per.friends.insert(pair<int, string>(104, "aaaaaaa"));
	per.experience.push_back(111111111);
	per.experience.push_back(222222222);
	per.experience.push_back(333333333);

	step = 0;
	serialize_person(sendBuf,per,step);

	memcpy(recvBuf, sendBuf, 1024);

	step = 0;
	deserialize(recvBuf,per2 ,step);

	cout << "收到的结构体中的信息为：" << endl;
	cout << "attribute=" << per.attribute << endl;
	cout << "name=" << per.name << endl;
	cout << "frients:" << endl;;
	for (map<int, string>::iterator it = per.friends.begin(); it != per.friends.end(); it++)
	{
		cout << "<" << it->first << "," << it->second << ">" << endl;
	}
	cout << "experience:";
	for (vector<long> ::iterator it = per.experience.begin(); it != per.experience.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	

	system("pause");
	return;
}