Question

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

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

我想为成员分配内存使用动态内存分配，在互联网上为每个示例分配指针的内存，我不能将我的数组表示为指针，我需要你的帮助asap家伙。谢谢。

Answer 1

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

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结构的函数。

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

1 个答案: