blocks|key|3171528|text|Boost::serialization库很好地处理了这一点。我已经在几个项目中使用过它。这里有一个示例程序，展示了如何使用它，here。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3171529|唯一的本机方法是使用streams。这就是Boost::serialization库所做的全部工作，它通过设置一个框架来扩展流方法，以便将对象写成类似文本的格式，并从相同的格式中读取它们。|3171530|对于内置类型，或者您自己正确定义了operator<<和operator>>的类型，这非常简单；有关更多信息，请参阅the+C%2B%2B+FAQ。|3171531|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_36_0/libs/serialization/doc/index.html|1|http://www.boost.org/doc/libs/1_36_0/libs/serialization/example/demo.cpp|2|https://isocpp.org/wiki/faq/serialization#serialize-simple-types^0|0|K|0|K|0|1S|4|1|0|L|K|0|H|A|S|A|1M|B|2|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]|$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|J|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]|T|$5|M|N|O|E|$P|U]]]]

The <a href="http://www.boost.org/doc/libs/1_36_0/libs/serialization/doc/index.html" rel="noreferrer"><code>Boost::serialization</code></a> library handles this rather elegantly. I've used it in several projects. There's an example program, showing how to use it, <a href="http://www.boost.org/doc/libs/1_36_0/libs/serialization/example/demo.cpp" rel="noreferrer">here</a>.

The only native way to do it is to use streams. That's essentially all the <code>Boost::serialization</code> library does, it extends the stream method by setting up a framework to write objects to a text-like format and read them from the same format. 

For built-in types, or your own types with <code>operator&lt;&lt;</code> and <code>operator&gt;&gt;</code> properly defined, that's fairly simple; see <a href="https://isocpp.org/wiki/faq/serialization#serialize-simple-types" rel="noreferrer">the C++ FAQ</a> for more information.

blocks|key|3172093|text|我知道这是一个古老的帖子，但它是搜索c%2B%2B+serialization时最先出现的帖子之一。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3172094|我鼓励任何能够访问C%2B%2B11的人看看cereal，这是一个仅支持C%2B%2B11头的序列化库，它开箱即用，支持二进制、JSON和XML。cereal被设计为易于扩展和使用，并具有类似于Boost的语法。|3172095|entityMap|0|LINK|mutability|MUTABLE|url|http://uscilab.github.io/cereal/^0|I|H|0|I|6|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

I realize this is an old post but it's one of the first that comes up when searching for <code>c++ serialization</code>.

I encourage anyone who has access to C++11 to take a look at <a href="http://uscilab.github.io/cereal/" rel="noreferrer">cereal</a>, a C++11 header only library for serialization that supports binary, JSON, and XML out of the box. cereal was designed to be easy to extend and use and has a similar syntax to Boost.

blocks|key|5429074|text|Boost是一个很好的建议。但如果你想自己动手，也不是很难。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5429075|基本上，您只需要一种方法来构建对象图，然后将它们输出为某种结构化存储格式(JSON、XML、YAML等)。构建图形就像利用标记递归的得体对象算法，然后输出所有标记的对象一样简单。|5429076|我写了一篇文章，描述了一个初级的(但仍然强大的)序列化系统。你可能会发现它很有趣：Using+SQLite+as+an+On-disk+File+Format,+Part+2。|offset|length|5429077|entityMap|0|LINK|mutability|MUTABLE|url|http://replay.waybackmachine.org/20090412173303/http://www.praeclarum.org/2006/03/using-sqlite-as-on-disk-file-format_31.html^0|0|0|15|1A|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Boost is a good suggestion. But if you would like to roll your own, it's not so hard.

Basically you just need a way to build up a graph of objects and then output them to some structured storage format (JSON, XML, YAML, whatever). Building up the graph is as simple as utilizing a marking recursive decent object algorithm and then outputting all the marked objects.

I wrote an article describing a rudimentary (but still powerful) serialization system. You may find it interesting: <a href="http://replay.waybackmachine.org/20090412173303/http://www.praeclarum.org/2006/03/using-sqlite-as-on-disk-file-format_31.html" rel="noreferrer">Using SQLite as an On-disk File Format, Part 2</a>.

blocks|key|5429207|text|就“内置”库而言，<<和>>是专门为序列化保留的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5429208|您应该重写<<以将对象输出到某个序列化上下文(通常为iostream)，并重写>>以从该上下文中读取数据。每个对象负责输出其聚合子对象。|5429209|只要你的对象图不包含循环，这个方法就能很好地工作。|5429210|如果是这样，那么您将不得不使用库来处理这些周期。|5429211|entityMap^0|9|2|C|2|0|5|2|Q|8|13|2|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|10|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|M|$]]

As far as "built-in" libraries go, the <code>&lt;&lt;</code> and <code>&gt;&gt;</code> have been reserved specifically for serialization.

You should override <code>&lt;&lt;</code> to output your object to some serialization context (usually an <code>iostream</code>) and <code>&gt;&gt;</code> to read data back from that context. Each object is responsible for outputting its aggregated child objects.

This method works fine so long as your object graph contains no cycles.

If it does, then you will have to use a library to deal with those cycles.

blocks|key|3171749|text|我推荐Google+protocol+buffers。我有机会在一个新项目上测试这个库，它非常容易使用。该库针对性能进行了大量优化。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3171750|Protobuf与这里提到的其他序列化解决方案的不同之处在于，它不序列化您的对象，而是根据您的规范为序列化的对象生成代码。|3171751|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/protobuf/^0|A|G|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

I recommend Google <a href="http://code.google.com/p/protobuf/" rel="noreferrer">protocol buffers</a>.
I had the chance to test drive the library on a new project and it's remarkably easy to use.
The library is heavily optimized for performance.

Protobuf is different than other serialization solutions mentioned here in the sense that it does not serialize your objects, but rather generates code for objects that are serialization according to your specification.

blocks|key|4018395|text|Boost::serialization是一个很好的选择，但我遇到了一个新项目：Cereal，我发现它要优雅得多！我强烈建议对其进行调查。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4018396|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_36_0/libs/serialization/doc/index.html|1|http://uscilab.github.io/cereal/^0|0|K|0|14|6|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

<a href="http://www.boost.org/doc/libs/1_36_0/libs/serialization/doc/index.html">Boost::serialization</a> is a great option, but I've encountered a new project: <a href="http://uscilab.github.io/cereal/">Cereal</a> which I find much more elegant! I highly suggest investigating it.

blocks|key|4018284|text|您可以查看协议，amef中的C%2B%2B编码示例如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4018285|++++//Create+a+new+AMEF+object
++++AMEFObject+*object+=+new+AMEFObject();

++++//Add+a+child+string+object
++++object->addPacket("This+is+the+Automated+Message+Exchange+Format+Object+property!!","adasd");+++

++++//Add+a+child+integer+object
++++object->addPacket(21213);

++++//Add+a+child+boolean+object
++++object->addPacket(true);

++++AMEFObject+*object2+=+new+AMEFObject();
++++string+j+=+"This+is+the+property+of+a+nested+Automated+Message+Exchange+Format+Object";
++++object2->addPacket(j);
++++object2->addPacket(134123);
++++object2->addPacket(false);

++++//Add+a+child+character+object
++++object2->addPacket('d');

++++//Add+a+child+AMEF+Object
++++object->addPacket(object2);

++++//Encode+the+AMEF+obejct
++++string+str+=+new+AMEFEncoder()->encode(object,false);|code-block|syntax|javascript|4018286|java中的解码将类似于，|4018287|++++string+arr+=+amef+encoded+byte+array+value;
++++AMEFDecoder+decoder+=+new+AMEFDecoder()
++++AMEFObject+object1+=+AMEFDecoder.decode(arr,true);|4018288|协议实现有C%2B%2B和Java的编解码器，有趣的是它可以保留名称值对形式的对象类表示，我在上一个项目中需要一个类似的协议，当我偶然发现这个协议时，我实际上已经根据我的要求修改了基库。希望这对你有帮助。|4018289|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can check the <a href="https://code.google.com/p/amef" rel="nofollow">amef</a> protocol, an example of C++ encoding in amef would be like,

<pre><code> //Create a new AMEF object
 AMEFObject *object = new AMEFObject();

 //Add a child string object
 object-&gt;addPacket("This is the Automated Message Exchange Format Object property!!","adasd"); 

 //Add a child integer object
 object-&gt;addPacket(21213);

 //Add a child boolean object
 object-&gt;addPacket(true);

 AMEFObject *object2 = new AMEFObject();
 string j = "This is the property of a nested Automated Message Exchange Format Object";
 object2-&gt;addPacket(j);
 object2-&gt;addPacket(134123);
 object2-&gt;addPacket(false);

 //Add a child character object
 object2-&gt;addPacket('d');

 //Add a child AMEF Object
 object-&gt;addPacket(object2);

 //Encode the AMEF obejct
 string str = new AMEFEncoder()-&gt;encode(object,false);
</code></pre>

Decoding in java would be like,

<pre><code> string arr = amef encoded byte array value;
 AMEFDecoder decoder = new AMEFDecoder()
 AMEFObject object1 = AMEFDecoder.decode(arr,true);
</code></pre>

The Protocol implementation has codecs for both C++ and Java, the interesting part is it can retain object class representation in the form of name value pairs,
I required a similar protocol in my last project, when i incidentally stumbled upon this protocol, i had actually modified the base library according to my requirements. Hope this helps you.

blocks|key|4018301|text|我推荐使用boost序列化，正如其他帖子所描述的那样。这里有一个关于如何使用它的很好的详细教程，它很好地补充了boost教程：http://www.ocoudert.com/blog/2011/07/09/a-practical-guide-to-c-serialization/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4018302|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ocoudert.com/blog/2011/07/09/a-practical-guide-to-c-serialization/^0|1R|25|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I recommend using boost serialization as described by other posters. Here is a good detailed tutorial on how to use it which complements the boost tutorials nicely: <a href="http://www.ocoudert.com/blog/2011/07/09/a-practical-guide-to-c-serialization/" rel="nofollow">http://www.ocoudert.com/blog/2011/07/09/a-practical-guide-to-c-serialization/</a>

blocks|key|4018569|text|是另一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4018570|可以序列化XML、JSON、Lua和二进制格式的流。|4018571|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

<a href="http://www.sweetsoftware.co.nz/persist_overview.html" rel="nofollow">Sweet Persist</a> is another one.

It is possible to serialize to and from streams in XML, JSON, Lua, and binary formats.

blocks|key|4018211|text|我建议研究一下抽象工厂，它通常被用作序列化的基础|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4018212|我已经回答了另一个关于C%2B%2B工厂的问题。如果对灵活的工厂感兴趣，请访问there。我试着描述一种来自ET%2B%2B的使用宏的旧方法，这种方法对我很有效。|offset|length|4018213|ET%2B%2B是一个将旧的MacApp移植到C%2B%2B和X11的项目。为此，Eric+Gamma等人开始考虑设计模式。ET%2B%2B包含在运行时进行序列化和自省的自动方法。|4018214|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/410823/factory-method-implementation-c/534396#534396|1|http://www.ubilab.org/publications/wei94.html^0|0|Z|5|0|0|0|4|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

I suggest looking into Abstract factories which is often used as a basis for serialization

I have answered in another SO question about C++ factories. Please see <a href="https://stackoverflow.com/questions/410823/factory-method-implementation-c/534396#534396">there</a> if a flexible factory is of interest. I try to describe an old way from ET++ to use macros which has worked great for me.

<a href="http://www.ubilab.org/publications/wei94.html" rel="nofollow noreferrer">ET++</a> was a project to port old MacApp to C++ and X11. In the effort of it Eric Gamma etc started to think about Design Patterns. ET++ contained automatic ways for serialization and introspection at runtime.

blocks|key|4018631|text|如果你想要简单和最佳的性能，并且不关心向后数据兼容性，可以试试HPS，它很轻量级，比Boost等要快得多，而且比Protobuf等更容易使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4018632|示例：|4018633|std::vector<int>+data({22,+333,+-4444});
std::string+serialized+=+hps::serialize_to_string(data);
auto+parsed+=+hps::parse_from_string<std::vector<int>>(serialized);|code-block|syntax|javascript|4018634|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/jl2922/hps^0|V|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

If you want simple and best performance and don't care about backward data compatibility, try <a href="https://github.com/jl2922/hps" rel="nofollow noreferrer">HPS</a>, it's lightweight, much faster than Boost, etc, and much easier to use than Protobuf, etc.

Example:

<pre><code>std::vector&lt;int&gt; data({22, 333, -4444});
std::string serialized = hps::serialize_to_string(data);
auto parsed = hps::parse_from_string&lt;std::vector&lt;int&gt;&gt;(serialized);
</code></pre>

blocks|key|4018685|text|这是我搞出来的一个简单的序列化程序库。它只有头，c11，并且有序列化基本类型的例子。这里有一个用于映射到类的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4018686|https://github.com/goblinhack/simple-c-plus-plus-serializer|offset|length|4018687|#include+"c_plus_plus_serializer.h"

class+Custom+{
public:
++++int+a;
++++std::string+b;
++++std::vector+c;

++++friend+std::ostream&+operator<<(std::ostream+&out,+
++++++++++++++++++++++++++++++++++++Bits+my)
++++{
++++++++out+<<+bits(my.t.a)+<<+bits(my.t.b)+<<+bits(my.t.c);
++++++++return+(out);
++++}

++++friend+std::istream&+operator>>(std::istream+&in,+
++++++++++++++++++++++++++++++++++++Bits+my)
++++{
++++++++in+>>+bits(my.t.a)+>>+bits(my.t.b)+>>+bits(my.t.c);
++++++++return+(in);
++++}

++++friend+std::ostream&+operator<<(std::ostream+&out,+
++++++++++++++++++++++++++++++++++++class+Custom+&my)
++++{
++++++++out+<<+"a:"+<<+my.a+<<+"+b:"+<<+my.b;

++++++++out+<<+"+c:["+<<+my.c.size()+<<+"+elems]:";
++++++++for+(auto+v+:+my.c)+{
++++++++++++out+<<+v+<<+"+";
++++++++}
++++++++out+<<+std::endl;

++++++++return+(out);
++++}
};

static+void+save_map_key_string_value_custom+(const+std::string+filename)
{
++++std::cout+<<+"save+to+"+<<+filename+<<+std::endl;
++++std::ofstream+out(filename,+std::ios::binary+);

++++std::map<+std::string,+class+Custom+>+m;

++++auto+c1+=+Custom();
++++c1.a+=+1;
++++c1.b+=+"hello";
++++std::initializer_list+L1+=+{"vec-elem1",+"vec-elem2"};
++++std::vector+l1(L1);
++++c1.c+=+l1;

++++auto+c2+=+Custom();
++++c2.a+=+2;
++++c2.b+=+"there";
++++std::initializer_list+L2+=+{"vec-elem3",+"vec-elem4"};
++++std::vector+l2(L2);
++++c2.c+=+l2;

++++m.insert(std::make_pair(std::string("key1"),+c1));
++++m.insert(std::make_pair(std::string("key2"),+c2));

++++out+<<+bits(m);
}

static+void+load_map_key_string_value_custom+(const+std::string+filename)
{
++++std::cout+<<+"read+from+"+<<+filename+<<+std::endl;
++++std::ifstream+in(filename);

++++std::map<+std::string,+class+Custom+>+m;

++++in+>>+bits(m);
++++std::cout+<<+std::endl;

++++std::cout+<<+"m+=+"+<<+m.size()+<<+"+list-elems+{+"+<<+std::endl;
++++for+(auto+i+:+m)+{
++++++++std::cout+<<+"++++["+<<+i.first+<<+"]+=+"+<<+i.second;
++++}
++++std::cout+<<+"}"+<<+std::endl;
}

void+map_custom_class_example+(void)
{
++++std::cout+<<+"map+key+string,+value+class"+<<+std::endl;
++++std::cout+<<+"============================"+<<+std::endl;
++++save_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
++++load_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
++++std::cout+<<+std::endl;
}|code-block|syntax|javascript|4018688|输出：|4018689|map+key+string,+value+class
============================
save+to+map_of_custom_class.bin
read+from+map_of_custom_class.bin

m+=+2+list-elems+{
++++[key1]+=+a:1+b:hello+c:[2+elems]:vec-elem1+vec-elem2
++++[key2]+=+a:2+b:there+c:[2+elems]:vec-elem3+vec-elem4
}|4018690|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1N|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|G|5|H|7|10|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|12|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|C]]]]

Here is a simple serializer library I knocked up. It's header only, c11 and
has examples for serializing basic types. Here's one for a map to class.

<a href="https://github.com/goblinhack/simple-c-plus-plus-serializer" rel="nofollow noreferrer">https://github.com/goblinhack/simple-c-plus-plus-serializer</a>

<pre><code>#include "c_plus_plus_serializer.h"

class Custom {
public:
 int a;
 std::string b;
 std::vector c;

 friend std::ostream&amp; operator&lt;&lt;(std::ostream &amp;out, 
 Bits my)
 {
 out &lt;&lt; bits(my.t.a) &lt;&lt; bits(my.t.b) &lt;&lt; bits(my.t.c);
 return (out);
 }

 friend std::istream&amp; operator&gt;&gt;(std::istream &amp;in, 
 Bits my)
 {
 in &gt;&gt; bits(my.t.a) &gt;&gt; bits(my.t.b) &gt;&gt; bits(my.t.c);
 return (in);
 }

 friend std::ostream&amp; operator&lt;&lt;(std::ostream &amp;out, 
 class Custom &amp;my)
 {
 out &lt;&lt; "a:" &lt;&lt; my.a &lt;&lt; " b:" &lt;&lt; my.b;

 out &lt;&lt; " c:[" &lt;&lt; my.c.size() &lt;&lt; " elems]:";
 for (auto v : my.c) {
 out &lt;&lt; v &lt;&lt; " ";
 }
 out &lt;&lt; std::endl;

 return (out);
 }
};

static void save_map_key_string_value_custom (const std::string filename)
{
 std::cout &lt;&lt; "save to " &lt;&lt; filename &lt;&lt; std::endl;
 std::ofstream out(filename, std::ios::binary );

 std::map&lt; std::string, class Custom &gt; m;

 auto c1 = Custom();
 c1.a = 1;
 c1.b = "hello";
 std::initializer_list L1 = {"vec-elem1", "vec-elem2"};
 std::vector l1(L1);
 c1.c = l1;

 auto c2 = Custom();
 c2.a = 2;
 c2.b = "there";
 std::initializer_list L2 = {"vec-elem3", "vec-elem4"};
 std::vector l2(L2);
 c2.c = l2;

 m.insert(std::make_pair(std::string("key1"), c1));
 m.insert(std::make_pair(std::string("key2"), c2));

 out &lt;&lt; bits(m);
}

static void load_map_key_string_value_custom (const std::string filename)
{
 std::cout &lt;&lt; "read from " &lt;&lt; filename &lt;&lt; std::endl;
 std::ifstream in(filename);

 std::map&lt; std::string, class Custom &gt; m;

 in &gt;&gt; bits(m);
 std::cout &lt;&lt; std::endl;

 std::cout &lt;&lt; "m = " &lt;&lt; m.size() &lt;&lt; " list-elems { " &lt;&lt; std::endl;
 for (auto i : m) {
 std::cout &lt;&lt; " [" &lt;&lt; i.first &lt;&lt; "] = " &lt;&lt; i.second;
 }
 std::cout &lt;&lt; "}" &lt;&lt; std::endl;
}

void map_custom_class_example (void)
{
 std::cout &lt;&lt; "map key string, value class" &lt;&lt; std::endl;
 std::cout &lt;&lt; "============================" &lt;&lt; std::endl;
 save_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
 load_map_key_string_value_custom(std::string("map_of_custom_class.bin"));
 std::cout &lt;&lt; std::endl;
}
</code></pre>

Output:

<pre><code>map key string, value class
============================
save to map_of_custom_class.bin
read from map_of_custom_class.bin

m = 2 list-elems {
 [key1] = a:1 b:hello c:[2 elems]:vec-elem1 vec-elem2
 [key2] = a:2 b:there c:[2 elems]:vec-elem3 vec-elem4
}
</code></pre>

blocks|key|5429929|text|我使用以下模板来实现序列化：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5429930|template+<class+T,+class+Mode+=+void>+struct+Serializer
{
++++template+<class+OutputCharIterator>
++++static+void+serializeImpl(const+T+&object,+OutputCharIterator+&&it)
++++{
++++++++object.template+serializeThis<Mode>(it);
++++}

++++template+<class+InputCharIterator>
++++static+T+deserializeImpl(InputCharIterator+&&it,+InputCharIterator+&&end)
++++{
++++++++return+T::template+deserializeFrom<Mode>(it,+end);
++++}
};

template+<class+Mode+=+void,+class+T,+class+OutputCharIterator>
void+serialize(const+T+&object,+OutputCharIterator+&&it)
{
++++Serializer<T,+Mode>::serializeImpl(object,+it);
}

template+<class+T,+class+Mode+=+void,+class+InputCharIterator>
T+deserialize(InputCharIterator+&&it,+InputCharIterator+&&end)
{
++++return+Serializer<T,+Mode>::deserializeImpl(it,+end);
}

template+<class+Mode+=+void,+class+T,+class+InputCharIterator>
void+deserialize(T+&result,+InputCharIterator+&&it,+InputCharIterator+&&end)
{
++++result+=+Serializer<T,+Mode>::deserializeImpl(it,+end);
}|code-block|syntax|javascript|5429931|这里，T是您想要序列化的类型，Mode是一个伪类型，用于区分不同类型的序列化，例如。可以将相同的整数序列化为小端、大端、varint等。|offset|length|style|CODE|5429932|默认情况下，Serializer将任务委托给被序列化的对象。对于内置类型，您应该对Serializer进行模板专门化。|5429933|还提供了方便函数模板。|5429934|例如，无符号整数的低端序列化：|5429935|struct+LittleEndianMode
{
};

template+<class+T>
struct+Serializer<
++++T,+std::enable_if_t<std::is_unsigned<T>::value,+LittleEndianMode>>
{
++++template+<class+InputCharIterator>
++++static+T+deserializeImpl(InputCharIterator+&&it,+InputCharIterator+&&end)
++++{
++++++++T+res+=+0;

++++++++for+(size_t+i+=+0;+i+<+sizeof(T);+i%2B%2B)
++++++++{
++++++++++++if+(it+==+end)+break;
++++++++++++res+%7C=+static_cast<T>(*it)+<<+(CHAR_BIT+*+i);
++++++++++++it%2B%2B;
++++++++}

++++++++return+res;
++++}

++++template+<class+OutputCharIterator>
++++static+void+serializeImpl(T+number,+OutputCharIterator+&&it)
++++{
++++++++for+(size_t+i+=+0;+i+<+sizeof(T);+i%2B%2B)
++++++++{
++++++++++++*it+=+(number+>>+(CHAR_BIT+*+i))+&+0xFF;
++++++++++++it%2B%2B;
++++++++}
++++}
};|5429936|然后进行序列化：|5429937|std::vector<char>+serialized;
uint32_t+val+=+42;
serialize<LittleEndianMode>(val,+std::back_inserter(serialized));|5429938|要反序列化：|5429939|uint32_t+val;
deserialize(val,+serialized.begin(),+serialized.end());|5429940|由于抽象迭代器逻辑，它应该与任何迭代器一起工作(例如，流迭代器)、指针等。|5429941|entityMap^0|0|0|3|1|F|4|0|6|A|15|A|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1D|8|@$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1N|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1O|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|1P|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|15|$]]

I'm using the following template to implement serialization:

<pre><code>template &lt;class T, class Mode = void&gt; struct Serializer
{
 template &lt;class OutputCharIterator&gt;
 static void serializeImpl(const T &amp;object, OutputCharIterator &amp;&amp;it)
 {
 object.template serializeThis&lt;Mode&gt;(it);
 }

 template &lt;class InputCharIterator&gt;
 static T deserializeImpl(InputCharIterator &amp;&amp;it, InputCharIterator &amp;&amp;end)
 {
 return T::template deserializeFrom&lt;Mode&gt;(it, end);
 }
};

template &lt;class Mode = void, class T, class OutputCharIterator&gt;
void serialize(const T &amp;object, OutputCharIterator &amp;&amp;it)
{
 Serializer&lt;T, Mode&gt;::serializeImpl(object, it);
}

template &lt;class T, class Mode = void, class InputCharIterator&gt;
T deserialize(InputCharIterator &amp;&amp;it, InputCharIterator &amp;&amp;end)
{
 return Serializer&lt;T, Mode&gt;::deserializeImpl(it, end);
}

template &lt;class Mode = void, class T, class InputCharIterator&gt;
void deserialize(T &amp;result, InputCharIterator &amp;&amp;it, InputCharIterator &amp;&amp;end)
{
 result = Serializer&lt;T, Mode&gt;::deserializeImpl(it, end);
}
</code></pre>

Here <code>T</code> is the type you want to serialize <code>Mode</code> is a dummy type to differentiate between different kinds of serialization, eg. the same integer can be serialized as little endian, big endian, varint, etc.

By default the <code>Serializer</code> delegates the task to the object being serialized. For built in types you should make a template specialization of the <code>Serializer</code>.

Convenience function templates are also provided.

For example little endian serialization of unsigned integers:

<pre><code>struct LittleEndianMode
{
};

template &lt;class T&gt;
struct Serializer&lt;
 T, std::enable_if_t&lt;std::is_unsigned&lt;T&gt;::value, LittleEndianMode&gt;&gt;
{
 template &lt;class InputCharIterator&gt;
 static T deserializeImpl(InputCharIterator &amp;&amp;it, InputCharIterator &amp;&amp;end)
 {
 T res = 0;

 for (size_t i = 0; i &lt; sizeof(T); i++)
 {
 if (it == end) break;
 res |= static_cast&lt;T&gt;(*it) &lt;&lt; (CHAR_BIT * i);
 it++;
 }

 return res;
 }

 template &lt;class OutputCharIterator&gt;
 static void serializeImpl(T number, OutputCharIterator &amp;&amp;it)
 {
 for (size_t i = 0; i &lt; sizeof(T); i++)
 {
 *it = (number &gt;&gt; (CHAR_BIT * i)) &amp; 0xFF;
 it++;
 }
 }
};
</code></pre>

Then to serialize:

<pre><code>std::vector&lt;char&gt; serialized;
uint32_t val = 42;
serialize&lt;LittleEndianMode&gt;(val, std::back_inserter(serialized));
</code></pre>

To deserialize:

<pre><code>uint32_t val;
deserialize(val, serialized.begin(), serialized.end());
</code></pre>

Due to the abstract iterator logic, it should work with any iterator (eg. stream iterators), pointer, etc.

blocks|key|3172331|text|C%2B%2B14+(C%2B%2B17推荐)+boost+prf|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3172332|3172333|没有宏|unordered-list-item|3172334|没有要显式编写的代码|3172335|3172336|demo|3172337|entityMap|0|LINK|mutability|MUTABLE|url|https://www.boost.org/doc/libs/1_75_0/doc/html/boost_pfr.html|1|https://godbolt.org/z/1qvPqx^0|G|9|0|0|0|0|0|0|0|4|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|-4|5|6|7|10|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|11|8|@]|9|@]|C|$]]|$1|H|3|I|5|G|7|12|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|M|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

C++14 (C++17 recommended) <a href="https://www.boost.org/doc/libs/1_75_0/doc/html/boost_pfr.html" rel="nofollow noreferrer">boost prf</a>
<ul>
<li>no macros</li>
<li>no code to be explicitly written</li>
</ul>
<a href="https://godbolt.org/z/1qvPqx" rel="nofollow noreferrer">demo</a>

Is it possible to serialize and deserialize a class in C++?

I've been using Java for 3 years now, and serialization / deserialization is fairly trivial in that language. Does C++ have similar features? Are there native libraries that handle serialization?

An example would be helpful.

Is it possible to serialize and deserialize a class in C++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在C++中可以序列化和反序列化一个类吗？我已经使用Java三年了，序列化/反序列化在该语言中相当简单。C++有类似的功能吗？是否有处理序列化的本机库？举个例子会很有帮助。

问在C++中可以序列化和反序列化一个类吗？
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中可以序列化和反序列化一个类吗？EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中可以序列化和反序列化一个类吗？
EN