Bonsoir à tous !

Je suis actuellement en train de coder un jeu et j'ai un petit problème (gros en fait) : à chaque nouvelle partie lancée, la mémoire que prend le programme augmente (en fait, au lieu de libérer l'ancienne, ça libère rien du tout et ça réalloue de la mémoire).

Bon c'est un peu vague dit comme ça, donc je vais vous expliquer ce que j'ai compris.

En fait, j'alloue de la mémoire dynamiquement sur des SDL_Surface* et pas moyen de libérer le malloc ...

voici un bout de programme pour vous montrer comment je m'y prends :

        monAnim->animsEntite[BOUGEPAS].anim = (SDL_Surface**)malloc(monAnim->animsEntite[BOUGEPAS].anims_totales * sizeof(SDL_Surface*));
        monAnim->animsEntite[BOUGE].anim = (SDL_Surface**)malloc(monAnim->animsEntite[BOUGE].anims_totales * sizeof(SDL_Surface*));

        monAnim->animsEntite[BOUGEPAS].animBase = (SDL_Surface**)malloc(monAnim->animsEntite[BOUGEPAS].anims_totales * sizeof(SDL_Surface*));
        monAnim->animsEntite[BOUGE].animBase = (SDL_Surface**)malloc(monAnim->animsEntite[BOUGE].anims_totales * sizeof(SDL_Surface*));

Ici j'alloue la mémoire dynamiquement. monAnim->animsEntite[X].anim est un SDL_Surface **. et monAnim est un pointeur (c'est dans une fonction). 

et après j'ai ça :

        for(i=0;i<monAnim.animsEntite[0].anims_totales;i++)
        {
            SDL_FreeSurface(monAnim.animsEntite[0].anim[i]);
            SDL_FreeSurface(monAnim.animsEntite[0].animBase[i]);
        }

        for(i=0;i<monAnim.animsEntite[1].anims_totales;i++)
        {
            SDL_FreeSurface(monAnim.animsEntite[1].anim[i]);
            SDL_FreeSurface(monAnim.animsEntite[1].animBase[i]);
        }
        free(monAnim.animsEntite[0].anim);
        free(monAnim.animsEntite[0].animBase);
        free(monAnim.animsEntite[1].anim);
        free(monAnim.animsEntite[1].animBase);

dans ma fonction jeu, avant de relancer la boucle qui réalloue. Est-ce que j'ai fait une erreur ici ?

Merci d'avance,

Un petit geek.

-
Edité par Diablo-hell 23 mai 2018 à 19:23:44

up !

Bonjour,

SDL_FreeSurface(monAnim.animsEntite[0].anim[i]);
SDL_FreeSurface(monAnim.animsEntite[0].animBase[i]);

Est-ce que tu libères les SDL_Surfaces suivantes ? (dans une boucle , je veux dire):

SDL_FreeSurface(monAnim.animsEntite[1].anim[i]);
SDL_FreeSurface(monAnim.animsEntite[1].animBase[i]);

-
Edité par Warren79 22 mai 2018 à 18:55:27

bonjour !

Absolument, excuse moi je l'ai pas mis. je le mets en edit tout de suite

Bonjour,

Si tu es sous Linux, il y a le greffon Valgrind qui te permet de traquer les fuites de mémoires (Valgrind est incorporé dans certains IDE , comme Codeblocks, Codelite, etc...). Il y a un tutoriel sur Open classrooms.

Sinon: je vois pas au premier abord de bug dans le bout de code que tu nous as posté. Par contre j'ai une recommandation : si tu utilises SDL_TTF , il faut libérer la SDL_Surface* avant de créer une autre SDL_Surface* avec TTF_FonctionDeSDLTTFQuiCreerUneTextureDeTexte(TTF_Font *font, const char*). Je te dis ça parce que si ton programme crée dans une boucle while() des SDL_Surface* ; donc pendant l' exécution d'un niveau ou d'une partie (par opposition à un stade du jeu où tu est par exemple dans le menu des options ou le menu principal) , les SDL_Surface* précédentes non libérées vont s'accumuler dans la mémoire donnant le phénomène que tu décris plus haut.

Bonjour ! 

Je suis sur windows :/ 

J'ai vérifié et j'avais oublié de libérer une police mais c'était la seule du programme et ça n'a absolument rien changé ... :/

Merci quand même ! d'autres idées ?

Je peux vous donner des précisions sur mon jeu pour pouvoir avoir des idées.

Je charge mes images, mes animations, polices et sons, et je lance le jeu. Quand je lance le jeu, j'ai une fonction "initAnim" qui initialise mes images que je modifie au cours du temps (je les aggrandis, etc ...) d'où le principe d'avoir une image de base et une actuelle, modifiée. Ensuite, j'ai une boucle de jeu normale où le jeu se passe, et à la fin de la partie, je libère les surfaces et je les recharge mais celles qu'il faut quand je recommence la partie.

En espérant pouvoir trouver mon bonheur ici !

Bonnesoirée et merci de votre attention !

Hello,

Diablo-hell a écrit:

....j'ai une fonction "initAnim" qui initialise mes images que je modifie au cours du temps (je les aggrandis, etc ...) ....

Très bien, mais en général, redimensionner une image (ou en faire une rotation) crée une nouvelle surface. As-tu penser à libérer ces nouvelles surfaces ?

Salut,

en fait je fais un truc du genre 

image = rotozoom(image, ....);

est-ce qu'on a le droit de le mettre comme ça ? ou est on obligé d'utiliser une surface intermédiaire à libérer ensuite ?

Merci

edit : je voulais dire, est-ce qu'on doit plutot mettre ça :

SDL_Surface *imgTemp = NULL;
image = rotozoom(image, ....);
SDL_FreeSurface(imgTemp);

-
Edité par Diablo-hell 24 mai 2018 à 22:25:04

Re,

rotozoom() crée une surface temporaire, qui est renvoyée.

DONC: image=rotozoom(image,...): le pointeur correspondant à la variable image passé en paramètre est perdu lors de l'affectation. Donc tu perds de la place. Donc oui, il faut passer par une surface intermédiaire. Voilà pourquoi tu perds de la mémoire.... heu, enfin, ton progamme....

-
Edité par edgarjacobs 24 mai 2018 à 23:35:00

En vrai je perds vraiment la mémoire, j'aurais dû m'en souvenir ...

Merci beaucoup ! Il est tard je vais me coucher j'ai cours tôt demain, mais je modifie tout ça dès que possible et je vous dit si il y a du mieux

Encore merci et bonne soirée !