Question

代码按预期工作，但它永远不会释放由malloc()分配的内存。

我试图在任何可以的地方释放记忆，但无论我在哪里，它都会破坏程序。具体来说，我得到了“双重免费或损坏错误”。这更像是free()和malloc()实际上做了什么的问题？免费的所有问题都在主要：

int main(int argc,  char *argv[]){
if(argc!=2){
    exit(1);
}

printf("CSA WC version 1.0\n\n");

int length = strlen(argv[argc-1]);
char file_to_open[length];
strcpy(file_to_open, argv[argc-1]);

//printf("filename:%s\n",file_to_open);

//create counters for output
int count_number_of_lines = 0;
int count_number_of_words = 0;
int count_number_of_characters = 0;

//create int size of default array size
int current_array_size = pre_read(file_to_open);
//printf("number of lines: %i\n",current_array_size);

//create string array of default size
char *strings_array[current_array_size];

//create a pointer to catch incoming strings
char *incoming_string=NULL;

int done=0;
while(done==0){
    incoming_string=get_line_from_file(file_to_open, count_number_of_lines);
    if(incoming_string!=NULL){
        incoming_string=csestrcpy2(incoming_string);
        //printf("incoming line: %s\n",incoming_string);
        strings_array[count_number_of_lines]=(char*)malloc(strlen(incoming_string+1));
        strings_array[count_number_of_lines]=csestrcpy2(incoming_string);
        //printf("added to array:%s\n",strings_array[count_number_of_lines]);
        count_number_of_lines++;
        count_number_of_characters=(count_number_of_characters+(strlen(incoming_string)-1));
    }
    else{
        done=1;
    }

}
//all data is stored in a properly sized array


//count all words in array
int count=0;
int word_count=0;
char *readline;

while(count<current_array_size){
    readline = csestrcpy2(strings_array[count]);
    printf("line being checked: %s", readline);

    int i=0;
    int j=1;

    while( j< strlen(readline)+1 ){
        if(strcmp(readline,"\n")!=0){
            if( (readline[i] == ' ') && (readline[j] != ' ') ){
                word_count++;
            }
            if( (readline[i] != ' ') && (readline[j] == '\n') ){
                word_count++;
            }
        }
        i++;
        j++;
    }
    count++;
}
printf("current word count: %i", word_count);
return 0;
}



char* csestrcpy2(char* src){

int i = 0;
char *dest;
char t;
dest = (char*) malloc(MAX_LINE);

while( src[i] != '\0'){

    dest[i] = src[i];
    i++;

}

dest[i] = '\0';
//printf("length:%i\n",i);
free(dest);

return dest;
}

Answer 1

通常，您只需释放已动态保留的内存。这意味着如果您有这样的声明：

int *my_int_pointer;
my_int_pointer = malloc(sizeof(int));

需要释放malloc分配（保留）的内存。如果你不确定在哪里释放它，而不是在节目结束时免费使用免费;

free(my_int_pointer);

在您的文件中，只要您读取的文件中有新行（在while(done==0)循环中），就会分配内存。因此，每次在此循环中的if之后，您必须释放变量使用的内存。

此外，您需要释放为readline变量分配的内存。但正如之前所指出的那样，你可能会有内存泄漏。

希望这有帮助。

编辑：好的 - 我已经想知道csestrcpy功能了。让我们来看看这个函数：

char* csestrcpy2(char* src){
    int i = 0;
    char *dest;
    char t;
    dest = (char*) malloc(MAX_LINE); /*<<- This allocates memory that has to be freed*/
    while( src[i] != '\0'){
        dest[i] = src[i];
        i++;
    }
    dest[i] = '\0';
    //printf("length:%i\n",i);
    free(dest);                  /* This frees the memory, but you return a pointer */
    return dest;                 /* to this memory. this is invalid.                */
}

你可以免费获得的是该函数中的src指针。但请记住：在释放底层内存后，指针无法保存信息！它只指向内存中不应该写或读的地方。

此外，只要没有'\ 0'，函数就会复制字符串。如果没有终结器会怎么样？该功能继续从一些内存地址复制，不应该在那里复制！

你不应该使用该功能;）

Answer 2

每次成功拨打free()都需要致电malloc()。

这不是必然意味着您需要在代码中拥有相同数量的malloc()和free()次调用;这意味着对于程序运行时执行的每个malloc()调用，您应该调用free()，并传递从malloc()获得的指针值。 malloc()分配内存; free()告诉系统您已完成分配的内存。

（当你的程序终止时，你几乎可以肯定没有free()ing已分配的内存，因为它将由操作系统回收，但是就风格和良好实践而言，你仍然应该匹配{{ 1}} {s} malloc() s。）

我忽略了free()和calloc()来电。

Answer 3

动态内存分配（malloc）分配一个请求大小的内存块，并返回一个指向该块开头的指针。因为我们从内存中取出了这个块，所以最好在完成后将它返回内存。任务。

现在作为你的问题的答案，为了永远保持安全，你可以在返回之前调用自由函数。

main{
    int *i;
    ..
    ..
    i=(int *)malloc(sizeof(int));
    ...//so something with i
    ..
    free(i);
    return 0;
}

Answer 4

作为一般规则，对于每个malloc，应该有相应的free。但是你不能free两次（正如你现在已经注意到的那样）。我的代码中没有看到对free的任何调用，因此无法说出问题所在，但我立即注意到您malloc了一些内存并将其分配给readline在循环内部，但是你没有在循环结束时在free上调用readline，所以你在那里泄漏内存。

Answer 5

将malloc和free视为“开始”和“结束”。任何时候你致电malloc，做你需要的事情，一旦你完成，总是打电话给free。确保只释放一次，double-free是运行时错误。

如果你以某种方式失去malloc返回的值（是的，这就是你的代码发生了什么），那么你就会发生内存泄漏（地狱的大门打开了，yada yada）。

重新迭代：释放malloc返回的任何内容（null除外）。

Answer 6

        i++;
        j++;
        /// free here
        free(readline);
    }
    count++;

}
printf("current word count: %i", word_count);

//free here as well
for(int k = 0; k < count_number_of_lines; k++)
{
    free(strings_array[count_number_of_lines]);
}

return 0;
}

这应该有用。

通常 - 动态分配的任何内存 - 使用calloc / malloc / realloc需要在指针超出范围之前使用free（）释放。

如果您使用'new'分配内存，则需要使用'delete'释放它。

Answer 7

这一行：

strings_array[count_number_of_lines]=(char*)malloc(strlen(incoming_string+1));

被旁边的行覆盖，因此可以将其删除。

您还应在最后一个循环中的free(readline)之后添加count++以释放malloc创建的内存。

我什么时候应该在C中使用free（）？

7 个答案: