blocks|key|788494|text|如果您正在考虑protobufs，那么您思考这个问题的方式将与您需要思考的方式相反。Protobufs不使用现有的数据结构并序列化它们。它们采用序列化协议，并为您创建填充的数据结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|788495|尽管如此，嵌套序列化非常简单：|788496|//+nested.proto
message+Inner+{
++++required+string+value+=+1;
}

message+Outer+{
++++required+Inner+inner+=+1;
}

message+Pointers+{
++++repeated+Outer+outer+=+1;
}|code-block|syntax|javascript|788497|假设您已经正确地编译了这个程序，那么您可以使用这个协议从外部运行。也就是说，从最高的结构Pointers开始，然后以您的方式进入Inner对象：|offset|length|style|CODE|788498|Pointers+pointers;
for+(int+i+=+0;+i+<+10;+%2B%2Bi)+{
++++auto+outer+=+pointers.add_outer();
++++auto+inner+=+outer->mutable_inner();
++++inner->set_value(std::to_string(i));
}

std::stringstream+stream;
pointers.SerializeToOstream(&stream);

...

Pointers+parsed_pointers;
parsed_pointers.ParseFromIstream(&stream);
for+(int+i+=+0;+i+<+parsed_pointers.outer_size();+%2B%2Bi)+{
++++std::cout+<<+parsed_pointers.outer(i).inner().value()+<<+std::endl;
}

//+This+prints+0,+1,+2,+...,+9+all+on+their+own+lines|788499|可以从Inner消息开始，但将所有权传递给Outer消息的方式并不那么简单或明显：|788500|Inner*+inner+=+new+Inner();
inner->set_value("Hello+world");
Outer+outer;
outer.set_allocated_inner(inner);|788501|调用该方法将捕获inner指针的所有权，这样您就不应该亲自手动执行delete。|788502|entityMap^0|0|0|0|18|8|1S|5|0|0|3|5|L|5|0|0|8|5|X|6|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@$K|12|L|13|M|N]|$K|14|L|15|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|17|8|@$K|18|L|19|M|N]|$K|1A|L|1B|M|N]]|9|@]|A|$]]|$1|S|3|T|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1D|8|@$K|1E|L|1F|M|N]|$K|1G|L|1H|M|N]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|X|$]]

The way you're thinking about this problem is the reverse of how you need to think if you're considering protobufs. Protobufs don't take an existing data structure and serialize them. They take a serialization protocol and create data structures for you that you populate.

With that said, nested serialization is pretty simple:

<pre><code>// nested.proto
message Inner {
 required string value = 1;
}

message Outer {
 required Inner inner = 1;
}

message Pointers {
 repeated Outer outer = 1;
}
</code></pre>

Assuming you've correctly compiled this, you can use this protocol working from the outside in. That is, you start with the highest structure, <code>Pointers</code>, and work your way into the <code>Inner</code> object:

<pre><code>Pointers pointers;
for (int i = 0; i &lt; 10; ++i) {
 auto outer = pointers.add_outer();
 auto inner = outer-&gt;mutable_inner();
 inner-&gt;set_value(std::to_string(i));
}

std::stringstream stream;
pointers.SerializeToOstream(&amp;stream);

...

Pointers parsed_pointers;
parsed_pointers.ParseFromIstream(&amp;stream);
for (int i = 0; i &lt; parsed_pointers.outer_size(); ++i) {
 std::cout &lt;&lt; parsed_pointers.outer(i).inner().value() &lt;&lt; std::endl;
}

// This prints 0, 1, 2, ..., 9 all on their own lines
</code></pre>

It's possible to start with the <code>Inner</code> message, but the way you pass ownership to an <code>Outer</code> message is not as simple or obvious:

<pre><code>Inner* inner = new Inner();
inner-&gt;set_value("Hello world");
Outer outer;
outer.set_allocated_inner(inner);
</code></pre>

Calling that method will capture ownership of the <code>inner</code> pointer so that you shouldn't manually <code>delete</code> it yourself.

blocks|key|785864|text|还有另一种方法，我认为也有帮助。因为.set_allocated_*(A)有副作用，会破坏A。要从A复制，可以尝试.mutable_*()->CopyFrom(A)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|785865|entityMap^0|I|J|19|1|1D|1|1L|P|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

There is another method I think also helpful. Since <code>.set_allocated_*(A)</code> has a side effect which will destroy <code>A</code>. To just copy from <code>A</code>, you can try <code>.mutable_*()-&gt;CopyFrom(A)</code>.

Say I had an array of pointers, each of which points to structs which may once again have pointers to other structs in them; is it possible to handle serializing this using protobuf? If so, how?

Any help would be greatly appreciated.

Deep-copying with ProtoBuf in C/C++

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

假设我有一个指针数组，每个指针指向结构，其中可能又有指向其他结构的指针；是否可以使用protobuf来处理这个序列化？如果是这样的话，是怎么做的？任何帮助都将不胜感激。

问C/C++中基于ProtoBuf的深度复制
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C/C++中基于ProtoBuf的深度复制EN