C语言 重新分配字符串数组

Question

所以我做了这个函数，它接收未知数量的字符串并将它们添加到字符串数组中。

char **receiveCode(int socket){
    int line = 0;
    size_t lines = 1;
    size_t size = 1;
    char** code = malloc(sizeof(char)*size);
    while(1){
        package_struct *aPackage = receivePackage(socket);
        if(aPackage->type=='F'){break;}
        size = size + aPackage->size;
        code = realloc(code, size);
        code[line] = malloc(sizeof(char)*aPackage->size);
        strcpy(code[line],aPackage->package);
        line++;
        lines++;
        free(aPackage);
    }
    code = realloc(code, size + 2);
    code[line] = malloc(sizeof(char)*3);
    code[lines]=NULL;
    return code;
}

有时当我运行此代码时，我收到以下错误

* glibc 检测到 ./pp： realloc（）： 无效的下一个大小： 0x00007f0f88001220 **

根据瓦尔格林德的说法，这发生在该功能中。

可能我使用了太多的 malloc 和 reallocs......不过不知道。

Answer 1

我认为问题是这样的：

char** code = malloc(sizeof(char)*size);

它应该是char *的，而不是char在里面sizeof()

char** code = malloc(sizeof(char*)*size);

由于code是指向字符串的指针，因此请为指针分配内存char*

realloc中也存在同样的问题

Answer 2

我假设这是分配一个char*数组：

code = realloc(code, size);

应该是

code = realloc(code, size * sizeof(char*));
// and this one too
code = realloc(code, size + 2 * sizeof(char*));

另外，您不需要这个：

char** code = malloc(sizeof(char)*size);

如果你打电话给realloc(NULL, size)它相当于malloc(size)

size_t size = 0;
char** code = NULL;
...
code = realloc(code, size * sizeof(char*));

注意：lines对我来说似乎没用，实际上在最后两行中，您覆盖了自line==lines以来刚刚分配的内存

Answer 3

这是一个使用strdup()来简化每个新文本行的内存分配的版本。它还使用内存分配函数的"x"版本来简化内存不足错误处理（一个有点常见的习惯用法，即使不是标准的）。

因此，真正剩下的所有复杂性（最终不会太多）都在于管理字符串指针数组的增长。我认为这样可以更轻松地将处理每个字符串与处理指针数组分开。原始代码混淆了这两个区域。

// these variants allocate memory, but abort program on failure
//  for simplified error handling - you may need different
//  error handling, but often this is enough
//
//  Also, your platform may or may not already have these functions
//      simplified versions are in the example.
void* xmalloc( size_t size);
void* xrealloc(void* ptr, size_t size);
char* xstrdup(char const* s);

char** receiveCode(int socket){
    size_t lines = 0;
    char** code = xmalloc( (lines + 1) * sizeof(*code));
    *code = NULL;
    while(1){
        package_struct *aPackage = receivePackage(socket);
        if(aPackage->type=='F') {
            free(aPackage); // not 100% sure if this should happen here or not.
                            // Is a `package_struct` with type 'F' dynamically
                            // allocated or is a pointer to a static sentinel 
                            // returned in this case?
            break;
        }

        // why use `aPackage->size` when you use `strcpy()` to
        //  copy the string anyway? Just let `strdup()` handle the details
        //
        // If the string in the `pckage_struct` isn't really null terminated, 
        // then use `xstrndup(aPackage->package, aPackage->size);` or something
        // similar.
        char* line = xstrdup(aPackage->package);
        ++lines;
        // add another pointer to the `code` array
        code = xrealloc(code, (lines + 1) * sizeof(*code));
        code[lines-1] = line;
        code[lines] = NULL;
        free(aPackage);
    }
    return code;
}

void* xmalloc(size_t size)
{
    void* tmp = malloc(size);
    if (!tmp) {
        fprintf(stderr, "%sn", "failed to allocate memory.n";
        exit(EXIT_FAILURE);
    }
    return tmp;
}
void* xrealloc(void *ptr, size_t size)
{
    void* tmp = realloc(ptr, size);
    if (!tmp) {
        fprintf(stderr, "%sn", "failed to allocate memory.n";
        exit(EXIT_FAILURE);
    }
    return tmp;
}

char* xstrdup(char const* s)
{
    char* tmp = strdup(s);
    if (!tmp) {
        fprintf(stderr, "%sn", "failed to allocate memory.n";
        exit(EXIT_FAILURE);
    }
    return tmp;
}

另外，我认为应该澄清aPackage->package是字符串指针还是保存字符串数据的char[]的实际位置（即，&aPackage->package应该传递给strcpy()/xstrdup()？ 如果它真的是一个指针，它是否应该在aPackage之前被释放？