对结构数组的动态内存分配。程序结束 [C]

Question

我检查了谷歌，但找不到任何解决方案。我正在制作一个程序，我需要使用动态内存分配。这是我使用的结构

struct profile {
char *item;
int lala;
char *lolo;
} members[];

我想使用动态内存分配为成员分配内存数组，在互联网上的每个样本中，它都为指针分配内存，我也不能将我的数组表示为指针。

Answer 1

我也不能将数组表示为指针。

在C中，除了通过指针表示动态分配的内存数组之外，没有其他方法。

我认为你的心理障碍源于这样一个概念，即结构的数据应该按照结构中定义的顺序排列。我很抱歉告诉你，但这在C语言中是不可能直接做到的。

当然，从获得的数据结构是完全可能的

size_t length;
char data[];
size_t length2
char data2[];

记忆中的某个地方。但是C中没有内置的对这种二进制数据流的支持。

你能做的最好的事情是拥有许多helper-pack/ounpack函数，这些函数使用一个指向某些内存的不透明指针，并且可以打包和解包到C结构中使用。

请注意，如果你想用它来解析文件的内容：不要那里只有怪物和恐惧。

---

编辑代码示例

例如，假设以下结构

typedef struct Foo {
size_t name_len;
char * name; /* since we know len, this doesn't need to be '' terminated */
size_t bar_len;
char * bar;  /* same as for name */
} Foo; /* typedef for the lazy */

您可以使用以下函数将其打包为二进制流

/* returns a pointer to memory dynamically allocated and filled
* with a packed representation of the contents of a Foo struct.
* Once no longer needed release the memory allocated using free()
*
* returns NULL in case of an error.
*/
void * fooPack(Foo const * const foo_data)
{
assert( NULL != foo_data );
size_t const foo_data_lenth =
foo_data->name_len
+ foo_data->bar_len
+ 2 * sizeof(size_t);
char * const packed = malloc( foo_data_length );
if( NULL == packed ) {
return NULL;
}
char * p = packed;
*((size_t*)p) = foo_data->name_len;
p += sizeof(size_t);
memcpy(p, foo_data->name, foo_data->name_len);
p += foo_data->name_len;
*((size_t*)p) = foo_data->bar_len;
p += sizeof(size_t);
memcpy(p, foo_data->bar, foo_data->bar_len);
return p;
}

开箱很简单

/* Unpacks a struct Foo with memory for name and bar allocated
* to match the data found in the packed data buffer.
*
* returns 0 on success and a negative value on error
*/
int fooUnpack(Foo * const foo_data, void const * const packed)
{
if( NULL == foo_data ) {
return -1;
}
if( NULL == packed ) {
return -2;
}
char const * p = packed;
/* unpack name */
size_t const name_len = *((size_t*)p);
p += sizeof(size_t);
char * name = malloc(name_len);
if( NULL == name ) {
return -3;
}
memcpy(name, p, name_len);
p += name_len;
/* unpack bar */
size_t const bar_len = *((size_t*)p);
p += sizeof(size_t);
char * bar = malloc(bar_len);
if( NULL == bar ) {
free( name );
return -4;
}
memcpy(bar, p, bar_len);
/* fill in foo_data */
foo_data->name_len = name_len;
foo_data->name = name;
foo_data->bar_len = bar_len;
foo_data->bar = bar;
return 0;
}

留给读者的练习：编写一个释放Foo结构的函数。