问题描述
我现在正处于系绳的尽头 - 花了几天时间试图
计算如何做到这一点。我终于写了一个简单的证明
概念用于测试将包含指针
的结构序列化为扁平化的程序。比特流。
这是我的代码（它不起作用）。
如果有任何有助于修复的反馈，我将不胜感激这个。我的意图
是建立在这个例子上，并使用这里的想法，以便能够坚持任何数据结构（我会为不同的程序编写不同的例程） br />
结构，只是为了简单起见）。无论如何，这里是代码：
#include" stdlib.h"
#include" stdio.h"
＃包括string.h
typedef struct {
int l;
double d;
char * S; / * Null终止字符串* /
} MyStruct;
void * pack（size_t * size，MyStruct * m）;
MyStruct * unpack （void * block）;
int main（int argc，char * argv []）{
MyStruct * in =（MyStruct *）malloc（sizeof （* in）），* out = NULL;
unsigned char * memblock = NULL;
size_t size;
in - > l = 1000;
in-> d = 3.142857;
in-> s = strdup（" Simple Text"）; / *我需要调整吗？ * /
memblock =（unsigned char *）pack（& size，in）;
out = unpack（memblock）;
printf（" Int成员有价值：％d（预期：％d）"，out-> l，in-> l）;
printf（ Double member has value：％f（expected：％f），out-> d，in-> d）;
printf（" Int member has value：％s （预期：％s）"，out-> s，in-> s）;
免费（in-> s）;
免费（里）;
免费（out-> s）;
免费（外出）;
}
void * pack（size_t * size，MyStruct * m）{
unsigned char * buff = NULL;
size_t len，length;
length = strlen（m-> s）;
len = sizeof（int）+ sizeof（double）+ sizeof （size_t）+
（长度+ 1）* sizeof（字符）;
buff =（unsigned char *）malloc（len）;
/ * copy int * /
memmove（buff，&（m-> l），sizeof（int））;
/ * copy双倍* /
memmo ve（buff + sizeof（int），&（m-> d），sizeof（double））;
/ *字符串存储长度* /
memmove （buff + sizeof（int）+ sizeof（int），& length，sizeof（size_t））;
/ * copy string * /
memmove（buff + sizeof （int）+ sizeof（double），m-> s，
（strlen（m-> s）+1）* sizeof（char））;
* size = len;
返回buff;
}
MyStruct * unpack（void * block）{
int l，len;
double d;
char * s = NULL;
MyStruct * p = NULL;
/ * get int * /
memcpy（& l，block，sizeof（int））;
/ * get double * /
memcpy（& d，（unsigned char *）block + sizeof（int），sizeof（double））;
/ * get string length * /
memcpy（& len，（unsigned char *）block + sizeof（int）+ sizeof（double），
sizeof（size_t））;
/ * get string * /
s =（char *）malloc（len + 1）;
memcpy（s，（unsigned char *）block + sizeof（int ）+ sizeof（ double）+
sizeof（size_t），len）;
p =（MyStruct *）malloc（sizeof（* p））;
p-> l = l;
p-> d = d;
p-> s = s;
/ *免费资源* /
免费（块）;
block = NULL;
返回p ;
}
Hi,
I am at the end of my tether now - after spending several days trying to
figure how to do this. I have finally written a simple "proof of
concept" program to test serializing a structure containing pointers
into a "flattened" bit stream.
Here is my code (it dosen''t work).
I would be grateful for any feedback that helps fix this. My intention
is to build on this example, and use the ideas here, to be able to
persist any data structure (I''ll write different routines for difdferent
stuctures, just to keep things simple). Anyway, here''s the code:
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
typedef struct {
intl ;
doubled ;
char*s; /* Null terminated string */
} MyStruct ;
void * pack(size_t *size, MyStruct* m);
MyStruct *unpack(void* block);
int main(int argc, char* argv[]) {
MyStruct *in = (MyStruct*)malloc(sizeof(*in)), *out = NULL;
unsigned char *memblock = NULL ;
size_t size ;
in->l = 1000 ;
in->d = 3.142857;
in->s = strdup("Simple Text" ); /*did I need to strdup? */
memblock = (unsigned char*)pack(&size, in) ;
out = unpack(memblock) ;
printf("Int member has value : %d (expected : %d)", out->l, in->l ) ;
printf("Double member has value : %f (expected : %f)", out->d, in->d ) ;
printf("Int member has value : %s (expected : %s)", out->s, in->s ) ;
free(in->s) ;
free(in) ;
free(out->s) ;
free(out) ;
}
void * pack(size_t *size, MyStruct* m) {
unsigned char *buff = NULL ;
size_t len, length ;
length = strlen(m->s) ;
len = sizeof(int) + sizeof(double) + sizeof(size_t) +
(length+1)*sizeof(char) ;
buff = (unsigned char*)malloc(len) ;
/*copy int*/
memmove(buff, &(m->l), sizeof(int)) ;
/*copy double*/
memmove(buff + sizeof(int), &(m->d), sizeof(double)) ;
/*store length of string*/
memmove(buff + sizeof(int) + sizeof(int), &length, sizeof(size_t));
/*copy string*/
memmove(buff + sizeof(int) + sizeof(double), m->s,
(strlen(m->s)+1)*sizeof(char)) ;
*size = len ;
return buff ;
}
MyStruct *unpack(void* block) {
int l, len ;
double d ;
char * s = NULL ;
MyStruct *p = NULL ;
/* get int*/
memcpy(&l, block, sizeof(int)) ;
/* get double*/
memcpy(&d, (unsigned char*)block + sizeof(int), sizeof(double)) ;
/* get string length*/
memcpy(&len, (unsigned char*)block + sizeof(int) + sizeof(double),
sizeof(size_t)) ;
/* get string*/
s = (char*)malloc(len+1) ;
memcpy(s,(unsigned char*)block + sizeof(int) + sizeof(double)+
sizeof(size_t),len) ;
p = (MyStruct*)malloc(sizeof(*p)) ;
p->l = l ;
p->d = d ;
p->s = s ;
/* free resource */
free(block) ;
block = NULL ;
return p ;
}
推荐答案
究竟是怎么回事？编译错误？分段故障？等等..
Exactly how doesn''t it work? Compile error? Segmentation Fault? Etc..
究竟是怎么回事？编译错误？分段故障？等等..
Exactly how doesn''t it work? Compile error? Segmentation Fault? Etc..
< snip>
（它不能正常工作 - 编译好，包似乎工作，但解压
检索乱码并导致程序崩溃）。
< / snip>
<snip>
(it dosen''t work - compiles fine, pack appears to work, but unpack
retrieves jibberish and causes program to crash).
</snip>
在返回之前分配给块的实现是什么？
顺便说一下，从代码中写入stdout的最后一个应该以
换行，并且没有换行的两个很多字符很难读取
！
What does assigning to block achieve just before a return?
Incidentally, the last write to stdout from your code should end in a
newline, and two many characters without a newline is rather hard to
read!
这篇关于这段代码出了什么问题？ （struct serialization to raw byte str的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！