Serialization 序列化/反序列化用户定义的类变量？

假设我有两个班：

class1 {
 int m_i;
 std::string m_s;
};

class2 {
 int m_i2;
 class1 *m_ptr;
};

现在，我想通过网络发送一个class2变量，并想使用任何进行序列化的库

---

我可以用哪一种？（注意class1*m_ptr）

你可以用节俭来做这个。 这个定义看起来像

struct class1 {
1: required i32 m_i;
2: required string m_s;
}
struct class2 {
1: required i32 m_i2;
2: optional class1 m_ptr;
}

你想读这本优秀的指南吗

---

为了澄清您在问题中提到的“指针”问题，请阅读上述指南中关于“嵌套结构是如何初始化的？”的部分。

您可以使用thrift。 这个定义看起来像

struct class1 {
1: required i32 m_i;
2: required string m_s;
}
struct class2 {
1: required i32 m_i2;
2: optional class1 m_ptr;
}

你想读这本优秀的指南吗

为了澄清您在问题中提到的“指针”问题，请阅读上述指南中关于“嵌套结构如何初始化？”的部分。

使用时，您需要一个.proto文件（比如test.proto），如：

使用C++，一旦运行PotoC编译器，就结束了Test.PB.CC和Test.P.H./P> 然后，您可以使用以下方法：

#包括
#包括“test.pb.h”
结构类别1{
国际货币基金组织；
std：：字符串m_s；
};
结构类2{
int m_i2；
类别1*m_ptr；
};
int main（）{
二等二班；
第二类：m_i2=2；
第二类。m_ptr=新的1类；
第二类。m_ptr->m_i=1；
第二类。m_ptr->m_s=“一”；
//序列化第2类
序列化：：class2可序列化的第二类；
可序列化的第二类.set\u m\u i2（第二类.m\u i2）；
如果（第二类m_ptr）{
序列化：：class1*serialisable_first_class=serialisable_second_class.mutable_m_ptr（）；
可序列化的\u第一类->设置\u m\u i（第二类.m\u ptr->设置\u i）；
可序列化第一类->设置第二类（第二类.m\u ptr->第二类）；
}
string序列化（serialisable_second_class.SerializeAsString（））；
//解析类2
序列化：：class2解析的第二类；
parsed_第二类。ParseFromString（序列化）；
第二类：第二类；
检索到的第二个类.m_i2=已解析的第二个类.m_i2（）；
if（已解析的第二个类has_m_ptr（））{
检索到的\u second\u class.m\u ptr=new class1；
检索到的第二个类.m_ptr->m_i=已解析的第二个类.m_ptr（）.m_i（）；
已检索的第二个类.m_ptr->m_s=已解析的第二个类.m_ptr（）.m_s（）；
}否则{
检索到的\u second\u class.m\u ptr=nullptr；
}
返回0；
}

注意，为了简洁起见，我这里没有做任何错误检查或异常处理——这在生产代码中是需要的。我也没有管理

class1

指针的生存期。

使用，您需要一个.proto文件（比如test.proto），如：

使用C++，一旦运行PotoC编译器，就结束了Test.PB.CC和Test.P.H./P> 然后，您可以使用以下方法：

#包括
#包括“test.pb.h”
结构类别1{
国际货币基金组织；
std：：字符串m_s；
};
结构类2{
int m_i2；
类别1*m_ptr；
};
int main（）{
二等二班；
第二类：m_i2=2；
第二类。m_ptr=新的1类；
第二类。m_ptr->m_i=1；
第二类。m_ptr->m_s=“一”；
//序列化第2类
序列化：：class2可序列化的第二类；
可序列化的第二类.set\u m\u i2（第二类.m\u i2）；
如果（第二类m_ptr）{
序列化：：class1*serialisable_first_class=serialisable_second_class.mutable_m_ptr（）；
可序列化的\u第一类->设置\u m\u i（第二类.m\u ptr->设置\u i）；
可序列化第一类->设置第二类（第二类.m\u ptr->第二类）；
}
string序列化（serialisable_second_class.SerializeAsString（））；
//解析类2
序列化：：class2解析的第二类；
parsed_第二类。ParseFromString（序列化）；
第二类：第二类；
检索到的第二个类.m_i2=已解析的第二个类.m_i2（）；
if（已解析的第二个类has_m_ptr（））{
检索到的\u second\u class.m\u ptr=new class1；
检索到的第二个类.m_ptr->m_i=已解析的第二个类.m_ptr（）.m_i（）；
已检索的第二个类.m_ptr->m_s=已解析的第二个类.m_ptr（）.m_s（）；
}否则{
检索到的\u second\u class.m\u ptr=nullptr；
}
返回0；
}

注意，为了简洁起见，我这里没有做任何错误检查或异常处理——这在生产代码中是需要的。我也没有管理

class1

指针的生命周期