c - 结构体数组的动态内存分配。计划结束 [C]

Question

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

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

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

Answer 1

I cannot represent my array as a pointer too.

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

我认为您的心理障碍源于这样的概念:结构的数据应该按照结构中定义的顺序排列。我很遗憾地告诉您，但这不可能在 C 中以简单的方式完成。

当然，完全有可能拥有 from 的数据结构

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

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

您能做的最好的事情就是拥有许多帮助程序打包/解包函数，这些函数采用指向某些内存的不透明指针，并且可以打包和解包到 C 结构以供使用。

请注意，如果您正在寻找使用它作为解析文件内容的方法:不要!那里只有怪物和恐惧。

<小时/>

编辑代码示例

例如假设以下结构

typedef struct Foo {
    size_t name_len;
    char * name; /* since we know len, this doesn't need to be '\0' 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 结构的函数。