重新分配字符串数组

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 * *

其中，据Valgrind说，发生在这个功能。

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

Answer 1

我认为这个问题是这样的：

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

应该char *，而不是char内sizeof()

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

由于code是一个指向字符串，以便为指针分配内存是char*

在也有同样的问题

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, "%s\n", "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, "%s\n", "failed to allocate memory.\n"; 
     exit(EXIT_FAILURE); 
    } 

    return tmp; 
} 


char* xstrdup(char const* s) 
{ 
    char* tmp = strdup(s); 

    if (!tmp) { 
     fprintf(stderr, "%s\n", "failed to allocate memory.\n"; 
     exit(EXIT_FAILURE); 
    } 

    return tmp; 
} 

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