Quand dois-je utiliser free() en C?

Le code fonctionne comme il est censé le faire, si elle ne libère la mémoire allouée par malloc().

J'ai essayé de libérer de la mémoire, en quelque lieu que je peux, mais peu importe où je le fais, il se casse le programme. Plus précisément, je reçois un "double gratuit ou erreur de corruption." C'est plus une question de savoir ce que free() et malloc() faire réellement? Tous les problèmes avec free sont dans la main:

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;
}
  • Il n'y a pas de raison de copie file_to_open de argv, vous pouvez simplement utiliser argv.
  • Curieux de savoir incoming_string=csestrcpy2(incoming_string); Est-ce juste une chaîne de caractères la fonction de copie?
  • Aussi, malloc(strlen(str+1)); est presque certainement faux. Vous signifiait probablement malloc(strlen(str)+1);. (Et beaucoup de gens, moi y compris, de recommander l'omission de la fonte de void * pointeurs être implicitement converti, et il peut causer des problèmes potentiels si vous convertir explicitement le mauvais type.)
  • csestrcopy2(incoming_string); une copie de chaîne de méthode qui renvoie une chaîne qui est la garantie d'avoir un '/0' à la fin de la ligne....
  • Merci de poster le code complet de votre csestrcopy2 fonction, car, à en juger par ce que vous avez posté dans les commentaires, c'est une partie de votre problème.
  • Récemment, j'ai modifié le code afin de refléter un changement que j'ai fait sur elle! le nombre de fois malloc() est dans le code a été réduit à un seul... je tiens à remercier tous ceux qui m'aident!
  • J'ai aussi ajouté le csestrcpy code ainsi
  • *note csestrcpy est une fonction à partir d'un autre fichier....

InformationsquelleAutor Koffeeaddict4eva | 2011-09-13
  1. 12

    En général, vous n'avez qu'à libérer de la mémoire qui a été réservé pour vous de façon dynamique. Cela signifie que si vous avez un énoncé comme ceci:

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

    que vous avez besoin de libérer la mémoire qui a été allouée (réservé) par malloc.
    si vous n'êtes pas certain de gratuit que de le libérer à la fin du programme, en utilisant free;

    free(my_int_pointer);

    Dans votre fichier, il semble comme il y aura de la mémoire allouée à chaque fois qu'il y a une nouvelle ligne dans le fichier de vous lire (dans le while(done==0) boucle). donc, à chaque fois après le if dans la boucle que vous avez à libérer la mémoire qui a été utilisée par la variable.

    En outre, vous devez libérer la mémoire qui a été allouée par la readline variable. Mais comme il a été souligné avant de vous peut avoir une fuite de mémoire là.

    Espère que cette aide.

    edit: Ok - j'avais déjà demandé sur le csestrcpy fonction. Permet d'avoir un oeil à cette fonction:

    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.                */
}

    Ce que vous pouvez, toutefois, le libre est la src pointeur dans cette fonction. mais rappelez-vous: le pointeur ne peut pas détenir des informations après le sous-jacent est libéré de la mémoire! Il a juste des points à un endroit de la mémoire où il ne faut pas écrire ou de lire plus.

    En outre la fonction copys la chaîne, tant qu'il n'y a pas de '\0'. Qu'advient-il si il n'y a pas de terminator? La fonction garde sur la copie de la mémoire les adresses où il ne devrait pas!

    vous ne devriez pas utiliser cette fonction 😉

    • essayé gratuit pour libérer de la mémoire, où l'on vous dit et a obtenu le: free(): pointeur non valide: 0xb76f5000 peut-être que c'est irrécupérable
    • Aussi, vous avez raison au sujet de la lecture en... je dois lire un fichier puis stocker chaque ligne lue dans dans une de taille appropriée null chaîne dans un tableau de chaînes de caractères... en fait, cela fonctionne très bien... puis-je libérer la mémoire allouée pour ce tableau, si je veux lire le tableau plus tard? Si je n'gratuit il je peux toujours lire le tableau? De combien de mémoire puis-je malloc() avant que mon programme est-il mort?
    • Ce n'est pas la syntaxe pour free.
    • oups... je viens récemment de travail avec le c++ et confus free(ptr); avec delete ptr;
    • Ce qui va se passer si je call call free() sur une variable créée avec la fonction malloc(), par exemple, si je reçois un pointeur vers une struct et j'appelle free() sur ce, mon programme crash ou est-il correct?
    InformationsquelleAutor Florian
  2. 6

    Il doit y avoir un appel à free() pour chaque appel réussi à malloc().

    Qui n'a pas nécessairement dire que vous devez avoir un nombre égal de malloc() et free() appels dans votre code, cela signifie que pour chaque malloc() appel qui est exécutée lorsque votre programme s'exécute, vous devez appeler free(), en lui passant le pointeur de la valeur que vous avez obtenu d' malloc(). malloc() alloue de la mémoire; free() indique au système que vous avez terminé avec la mémoire allouée.

    (Vous pouvez presque certainement vous en sortir avec pas free()ing mémoire allouée lorsque votre programme se termine, car il sera récupéré par le système d'exploitation, mais seulement comme une question de style et de bonnes pratiques que vous devriez toujours correspondre à malloc()s avec free()s.)

    Je suis ignorant calloc() et realloc() appels.

    • Pourriez-vous décrire le scénario(s) en cas d'utilisation de free() est une nécessité absolue? Depuis OS gère, pourquoi devrait-on jamais arriver à l'utiliser (en dehors de "bonne pratique")?
    • Pensez à un programme qui est en boucle, l'allocation de mémoire à chaque itération. Si elle n'est pas libre de sa mémoire allouée, il sera vite épuisé.
    InformationsquelleAutor Keith Thompson
  3. 3

    Allocation dynamique de la mémoire (malloc) alloue un bloc de mémoire de taille demandée, et renvoie un pointeur sur le début de ce bloc.Depuis que nous avons pris ce bloc de mémoire de sorte que son une bonne pratique pour revenir à ce retour de mémoire après l'achèvement de la tâche.

    Maintenant pour répondre à votre question , À toujours être sur le côté sûr, vous pouvez appeler libre de la fonction avant de faire retour.

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

    En règle générale, pour chaque malloc il devrait y avoir un correspondant free. Cependant on ne peut pas free deux fois la même chose (comme vous l'avez remarqué). Je ne vois pas tous les appels à free dans votre code, il est donc impossible de dire où votre problème, mais j'ai remarqué tout de suite que vous malloc de la mémoire et de l'attribuer à readline à l'intérieur d'une boucle, mais vous n'appelez pas free sur readline à la fin de la boucle, de sorte que vous êtes une fuite de mémoire là.

    • si j'ai des frais à la fin de la boucle, alors le programme meurt... si je suis libre après la boucle, alors le programme meurt... si je le libérer à la fin du programme le programme meurt.... il semble aller comme ça, pour n'importe quelle combinaison de libère à tout moment dans le programme...
    • Il n'est certainement pas. Je voulais dire à la fin de chaque itération. Le nombre d'itérations est inconnu, de sorte que vous devez être de nettoyer après vous. Que faire si vous êtes à la lecture d'un fichier énorme? Ne créez pas votre code ne fonctionne qu'en vertu de la plus triviale de conditions, et vous devriez prendre l'habitude d'écrire un code correct, de toute façon.
    InformationsquelleAutor Ed S.
  5. 0

    Pense malloc et free comme "début" et "fin". TOUTES les fois que vous appelez malloc, faire ce que vous devez et une fois que vous avez terminé, toujours faire appel à free. Assurez-vous de ne le libérer une fois, double-libre est une erreur d'exécution.

    Si vous en quelque sorte perdre de la valeur retournée par malloc (oui, c'est ce qui se passe avec votre code), alors vous avez une fuite de mémoire (et les portes de l'enfer s'ouvrir, yada yada).

    De ré-itérer: gratuit quelque malloc renvoie (à l'exception de la valeur null).

    • Comment puis-je tuer la fuite de mémoire? ou au moins savoir où il était?
    • Vous ne pouvez pas "tuer" une fuite de mémoire, il arrive quand le programme se termine sans la libération de la mémoire, elle a alloué. La plupart des systèmes d'Exploitation de garder une trace de la mémoire allouée et gratuit sur leur propre, mais il n'est pas garanti. Vous devez redémarrer votre système d'exploitation pour récupérer la mémoire. Vous compilez votre programme de prise en charge du débogage activé (-g de gcc) et ensuite utiliser un débogueur tels que gdb ou valgrind. valgrind a même un outil appelé memcheck qui affiche la liste des mémoires qui ont été attribués (et où)
    • Génial merci j'ai aussi trouvé un moyen de faire un code de ré-écriture qui nécessite seulement un malloc()... j'apprécie tous de votre aide!
    • désolé, mais c'est incorrect. Le système d'exploitation n'a en effet garder la trace de la mémoire allouée à un programme particulier. Toutefois, lorsque le programme se termine, le système d'exploitation peut et ne récupérer tout ce que la mémoire. Le dernier système d'exploitation qui n' pas ce faire, l'iirc a Windows 98 (c'est pourquoi il avait besoin de redémarrer si souvent).
    • En fait, il est parfaitement légal de free() un pointeur NULL (par exemple, retourné par malloc dans votre dernière phrase). La libc ne rien faire, comme spécifié dans la norme. Toutefois, certaines règles de codage peuvent se plaindre à ce sujet, car il peut montrer que le programmeur n'a pas d'idée claire de ce qui se passe avec les blocs alloués et qu'il est possible les fuites de mémoire d'ailleurs.
    • Je pensais que c'était juste delete. Intéressant.
    • Merci pour l'info. C'est ce que je voulais dire par les systèmes d'Exploitation Modernes. Mais la plupart des systèmes embarqués de ne pas le garantir. C'est pourquoi j'ai mentionné. De toute façon, c'est une mauvaise pratique de programmation laisser les fuites de mémoire dans votre programme. 🙂

    InformationsquelleAutor Chris Eberle
  6. 0

    Cette ligne:

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

    est remplacée par la ligne à côté de lui, de sorte qu'il peut être supprimé.

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

    • je ne peux pas supprimer la ligne ou le tableau de chaînes de caractères ne se remplit jamais ainsi, lorsque j'essaie d'accéder au tableau de chaînes de caractères, plus tard, même juste pour l'imprimer, il me donne un tableau avec rien dedans?
    • aussi j'ai essayé d'ajouter que gratuit et a obtenu: double gratuit ou de corruption (en haut): 0x088113c8 et le programme de cassé...
    InformationsquelleAutor alf
  7. 0
            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 la mémoire allouée dynamiquement à l'aide de calloc/malloc/realloc a besoin d'être libérée à l'aide de free() avant le pointeur est hors de portée.

    Si vous allouer de la mémoire à l'aide de "nouveau", puis vous avez besoin de l'aide de 'supprimer'.

    • essayé les deux, et tous deux me donner le double de gratuit ou de corruption (en haut): 0x088113c8
    • Avez édité le post. je suis désolé, la libre doit être juste après les itérateurs, avant l' } et non pas après. aussi strings_array[count_number_of_lines]=(char*)malloc(strlen(incoming_string+1)); doit être strings_array[count_number_of_lines]=(char*)malloc(strlen(incoming_string)+1)); ensuite, essayez de le libérer, comme indiqué ci - dessus, il doit travailler
    • Vous avez écrit libre(dest) et ensuite vous retourner! Il ne veut pas retourner une chaîne de caractères. vous n'avez pas besoin de libérer de la mémoire, là. si vous le supprimer puis de le libérer à la fin, il devrait fonctionner correctement.
    InformationsquelleAutor Jan S