blocks|key|5317153|text|根本就没有。C%2B%2B没有内置的序列化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5317154|您必须将单个对象写入字节数组/向量，并且要小心endianness+(如果您希望代码可移植)。|offset|length|5317155|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Endianness^0|0|N|A|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

There isn't one. C++ doesn't have built-in serialization.

You would have to write individual objects to a byte array/vector, and being careful about <a href="http://en.wikipedia.org/wiki/Endianness" rel="nofollow">endianness</a> (if you want your code to be portable).

blocks|key|3205557|text|你可以看看Boost.Serialization，但我怀疑你能不能让它使用与Python包相同的格式。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3205558|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_53_0/libs/serialization/doc/index.html^0|5|J|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]]]]

You could check out <a href="http://www.boost.org/doc/libs/1_53_0/libs/serialization/doc/index.html" rel="nofollow">Boost.Serialization</a>, but I doubt you can get it to use the same format as Python's pack.

blocks|key|5317304|text|从长远来看，使用第三方库(例如Google+Protocol+Buffers)可能会更好，但如果您坚持使用自己的库，示例的C%2B%2B版本可能如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5317305|#include+<stdint.h>
#include+<string.h>

int32_t+myValueToPack+=+1234;++//+or+whatever
uint8_t+myByteArray[sizeof(myValueToPack)];
int32_t+bigEndianValue+=+htonl(myValueToPack);++//+convert+the+value+to+big-endian+for+cross-platform+compatibility
memcpy(&myByteArray[0],+&bigEndianValue,+sizeof(bigEndianValue));
//+At+this+point,+myByteArray+contains+the+"packed"+data+in+network-endian+(aka+big-endian)+format|code-block|syntax|javascript|5317306|相应的“解包”代码将如下所示：|5317307|//+Assume+at+this+point+we+have+the+packed+array+myByteArray,+from+before
int32_t+bigEndianValue;
memcpy(&bigEndianValue,+&myByteArray[0],+sizeof(bigEndianValue));
int32_t+theUnpackedValue+=+ntohl(bigEndianValue);|5317308|在实际生活中，您可能会打包多个值，这很容易做到(通过增大数组大小并在循环中调用htonl()和memcpy()+--不要忘记在执行过程中增加memcpy()的第一个参数，这样第二个值就不会覆盖第一个值在数组中的位置，等等)。|5317309|您可能还想打包(又称序列化)不同的数据类型。Uint8_t(又称chars)和布尔值非常简单，因为它们不需要进行endian处理--您只需将它们作为单个字节逐字复制到数组中即可。Uint16_t可以通过htons()转换为big-endian，然后通过ntohs()转换回native-endian。浮点值有点棘手，因为没有内置的htonf()，但您可以使用自己的htonf()在符合IEEE754的机器上工作：|5317310|uint32_t+htonf(float+f)
{
+++uint32_t+x;
+++memcpy(&x,+&f,+sizeof(float));
+++return+htonl(x);
}|5317311|……和相应的ntohf()来解压它们：|5317312|float+ntohf(uint32_t+nf)
{
+++float+x;
+++nf+=+ntohl(nf);
+++memcpy(&x,+&nf,+sizeof(float));
+++return+x;
}|5317313|最后，对于字符串，您可以通过memcpy将字符串的字节添加到缓冲区(包括NUL终止符)：|5317314|const+char+*+s+=+"hello";
int+slen+=+strlen(s);
memcpy(myByteArray,+s,+slen%2B1);++//+%2B1+for+the+NUL+byte|5317315|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

You'll probably be better off in the long run using a third party library (e.g. Google Protocol Buffers), but if you insist on rolling your own, the C++ version of your example might be something like this:

<pre><code>#include &lt;stdint.h&gt;
#include &lt;string.h&gt;

int32_t myValueToPack = 1234; // or whatever
uint8_t myByteArray[sizeof(myValueToPack)];
int32_t bigEndianValue = htonl(myValueToPack); // convert the value to big-endian for cross-platform compatibility
memcpy(&amp;myByteArray[0], &amp;bigEndianValue, sizeof(bigEndianValue));
// At this point, myByteArray contains the "packed" data in network-endian (aka big-endian) format
</code></pre>

The corresponding 'unpack' code would look like this:

<pre><code>// Assume at this point we have the packed array myByteArray, from before
int32_t bigEndianValue;
memcpy(&amp;bigEndianValue, &amp;myByteArray[0], sizeof(bigEndianValue));
int32_t theUnpackedValue = ntohl(bigEndianValue);
</code></pre>

In real life you'd probably be packing more than one value, which is easy enough to do (by making the array size larger and calling htonl() and memcpy() in a loop -- don't forget to increase memcpy()'s first argument as you go, so that your second value doesn't overwrite the first value's location in the array, and so on).

You'd also probably want to pack (aka serialize) different data types as well. uint8_t's (aka chars) and booleans are simple enough as no endian-handling is necesary for them -- you can just copy each of them into the array verbatim as a single byte. uint16_t's you can convert to big-endian via htons(), and convert back to native-endian via ntohs(). Floating point values are a bit tricky, since there is no built-in htonf(), but you can roll your own that will work on IEEE754-compliant machines:

<pre><code>uint32_t htonf(float f)
{
 uint32_t x;
 memcpy(&amp;x, &amp;f, sizeof(float));
 return htonl(x);
}
</code></pre>

.... and the corresponding ntohf() to unpack them:

<pre><code>float ntohf(uint32_t nf)
{
 float x;
 nf = ntohl(nf);
 memcpy(&amp;x, &amp;nf, sizeof(float));
 return x;
}
</code></pre>

Lastly for strings you can just add the bytes of the string to the buffer (including the NUL terminator) via memcpy:

<pre><code>const char * s = "hello";
int slen = strlen(s);
memcpy(myByteArray, s, slen+1); // +1 for the NUL byte
</code></pre>

blocks|key|2223176|text|我也在寻找同样的东西。幸运的是我找到了https://github.com/mpapierski/struct|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2223177|只需添加一些功能，您就可以将缺少的类型添加到struct.hpp中，我认为这是目前为止最好的。|2223178|要使用它，只需像这样定义参数|2223179|DEFINE_STRUCT(test,
++++((2,+TYPE_UNSIGNED_INT))
++++((20,+TYPE_CHAR))
++++((20,+TYPE_CHAR))
)|code-block|syntax|javascript|2223180|只需调用将在编译时生成此函数|2223181|pack(unsigned+int+p1,+unsigned+int+p2,+const+char+*+p3,+const+char+*+p4)|2223182|参数的数量和类型将取决于您上面定义的内容。返回类型是char*，它包含打包的数据。还有另一个可用于读取缓冲区的unpack()函数|2223183|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/mpapierski/struct^0|J|10|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|15|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|18|8|@]|9|@]|C|$K|L]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

I was also looking for the same thing. Luckily I found <a href="https://github.com/mpapierski/struct" rel="nofollow noreferrer">https://github.com/mpapierski/struct</a>

with a few additions you can add missing types into struct.hpp, I think it's the best so far.

To use it, just define you params like this 

<pre><code>DEFINE_STRUCT(test,
 ((2, TYPE_UNSIGNED_INT))
 ((20, TYPE_CHAR))
 ((20, TYPE_CHAR))
)
</code></pre>

The just call this function which will be generated at compilation

<pre><code>pack(unsigned int p1, unsigned int p2, const char * p3, const char * p4)
</code></pre>

The number and type of parameters will depend on what you defined above.
The return type is a char* which contains your packed data. 
There is also another unpack() function which you can use to read the buffer

blocks|key|2216833|text|您可以使用union将不同的视图放入同一内存中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2216834|例如：|2216835|union+Pack{
+++int+i;
+++char+c[sizeof(int)];
};

Pack+p+=+{};
p.i+=+1234;
std::string+packed(p.c,+sizeof(int));+//+"\xd2\x04\x00\0"|code-block|syntax|javascript|2216836|正如在其他答案中所提到的，您必须注意字节顺序。|2216837|entityMap^0|5|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|V|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You can use <code>union</code> to get different view into the same memory.

For example:

<pre><code>union Pack{
 int i;
 char c[sizeof(int)];
};

Pack p = {};
p.i = 1234;
std::string packed(p.c, sizeof(int)); // "\xd2\x04\x00\0"
</code></pre>

As mentioned in the other answers, you have to notice the endianness.

blocks|key|3205685|text|https://github.com/karkason/cppystruct|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3205686|#include+"cppystruct.h"

//+icmp_header+can+be+any+type+that+supports+std::size+and+std::data+and+holds+bytes
auto+[type,+code,+checksum,+p_id,+sequence]+=+pystruct::unpack(PY_STRING("bbHHh"),+icmp_header);

int+leet+=+1337;
auto+runtimePacked+=+pystruct::pack(PY_STRING(">2i10s"),+leet,+20,+"String!");
//+runtimePacked+is+an+std::array+filled+with+"\x00\x00\x059\x00\x00\x00\x10String!\x00\x00\x00"
//+The+format+is+"compiled"+and+has+zero+overhead+in+runtime

constexpr+auto+packed+=+pystruct::pack(PY_STRING("<2i10s"),+10,+20,+"String!");
//+packed+is+an+std::array+filled+with+"\x00\x01\x00\x00\x10\x00\x00\x00String!\x00\x00\x00"|code-block|syntax|javascript|3205687|entityMap|0|LINK|mutability|MUTABLE|url^0|0|12|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|4]]]]

<a href="https://github.com/karkason/cppystruct" rel="nofollow noreferrer">https://github.com/karkason/cppystruct</a>
<pre><code>#include &quot;cppystruct.h&quot;

// icmp_header can be any type that supports std::size and std::data and holds bytes
auto [type, code, checksum, p_id, sequence] = pystruct::unpack(PY_STRING(&quot;bbHHh&quot;), icmp_header);

int leet = 1337;
auto runtimePacked = pystruct::pack(PY_STRING(&quot;&gt;2i10s&quot;), leet, 20, &quot;String!&quot;);
// runtimePacked is an std::array filled with &quot;\x00\x00\x059\x00\x00\x00\x10String!\x00\x00\x00&quot;
// The format is &quot;compiled&quot; and has zero overhead in runtime

constexpr auto packed = pystruct::pack(PY_STRING(&quot;&lt;2i10s&quot;), 10, 20, &quot;String!&quot;);
// packed is an std::array filled with &quot;\x00\x01\x00\x00\x10\x00\x00\x00String!\x00\x00\x00&quot;
</code></pre>

I used struct.pack in Python to transform a data into serialized byte stream. 

<pre><code>&gt;&gt;&gt; import struct
&gt;&gt;&gt; struct.pack('i', 1234)
'\xd2\x04\x00\x00'
</code></pre>

What is the equivalence in C++?

Python's struct.pack/unpack equivalence in C++

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我在Python语言中使用struct.pack将数据转换为序列化的字节流。>>> import struct>>> struct.pack('i', 1234)'\xd2\x04\x00\x00'C++中的等价性是什么？

问Python的struct.pack/unpack在C++中的等价性
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python的struct.pack/unpack在C++中的等价性EN