Quand dois-je utiliser free() en C ?

Question

Le code fonctionne comme il est censé le faire, bien qu'il ne libère jamais la mémoire allouée par la fonction malloc() .

J'ai essayé de libérer de la mémoire partout où je le pouvais, mais peu importe où je le fais, cela casse le programme. Plus précisément, j'obtiens un "double free or corruption error". Il s'agit plutôt d'une question sur ce que free() y malloc() font-ils réellement ? Tous les problèmes liés à la gratuité se situent dans l'ensemble :

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

        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;
}

Cela devrait fonctionner.

En général, toute mémoire allouée dynamiquement - en utilisant calloc/malloc/realloc - doit être libérée en utilisant free() avant que le pointeur ne sorte de sa portée.

Si vous allouez de la mémoire en utilisant 'new', vous devez la libérer en utilisant 'delete'.

Answer 2

Cette ligne :

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

est remplacée par la ligne suivante, elle peut donc être supprimée.

Vous devez également ajouter free(readline) après count++ dans la dernière boucle pour libérer la mémoire créée par malloc.