Partage

Fuite de mémoire

apres avoir blitté de 800*650 environ

Sujet résolu

9 juillet 2007 à 20:38:14

Bonjour,

Je suis en train de programmer un jeu. Mais j'ai un petit probleme :
Il y a une fuite de mémoire (a moins que quand g++ dit : make: *** [start] Abandon (vidange mémoire), ce soit autre chose).

Cet erreur se met lorsque je veux retourner dans le menu principale de mon jeu :
j'ai plusieur boucle d'evenement imbriqué les une dans les autres et l'erreur se fait lorsque je clique quelque part, dans la troisieme boucle(pour retourné dans la premiere).

J'ai des images qui font environ 800*650(une par boucle d'évenement) et qui doivent être blitté.
Si vous voulez voir le code, pour plus de précision, il faut juste demander. Je le montre pas tout de suite car il est assez long.

Merci d'avance pour les réponses

Anonyme

9 juillet 2007 à 20:46:34

Comme souvent, sans ton code, on ne peut rien faire

EPonix

9 juillet 2007 à 20:53:26

Le code est découpé en plusieurs fichier et fonction :
main.cpp :

#include <iostream>

#include "ClassFenetre.h"
#include "ClassImage.h"

#include "jeu.h"
#include "constantes.h"

void menuPrinc(SDL_Surface* ecran);

int main(int argc, char* argv[]) {
Fenetre ecran(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_DOUBLEBUF | SDL_HWSURFACE, SDL_INIT_VIDEO, "Zozor's Aventures - La Revanche du Site");
ecran.SDLInit();
ecran.creerFenetre();

menuPrinc(ecran.getEcran());

return EXIT_SUCCESS;
}

void menuPrinc(SDL_Surface* ecran) {
Image menu(3, 3, "data/images/menu.png");

bool affiche = true;

SDL_Event event;
while(SDL_WaitEvent(&event)) {
//Si on clique sur la croix
if(event.type == SDL_QUIT) exit(EXIT_SUCCESS);

//Si il y a un clique de souris
if(event.type == SDL_MOUSEBUTTONUP) {
//Si c'est un clique gauche
if(event.button.button = SDL_BUTTON_LEFT) {
//Si on clique sur le premier bouton du menu
if(event.button.x >= 54 && event.button.x <= 424) {
if(event.button.y >= 393 && event.button.y <= 401) {
//Jeu en mode facile
jeuApprentissage(ecran, 1);
affiche = true;
}
}

//Si on clique sur le deuxième bouton du menu
if(event.button.x >= 54 && event.button.x <= 472) {
if(event.button.y >= 403 && event.button.y <= 414) {
//Jeu en mode moyen
jeuApprentissage(ecran, 2);
affiche = true;

}
}

//Si on clique sur le troisième bouton du menu
if(event.button.x >= 54 && event.button.x <= 422) {
if(event.button.y >= 418 && event.button.y <= 430) {
//Jeu en mode difficile
jeuApprentissage(ecran, 3);
affiche = true;

}
}

//Si on clique sur le quatrieme bouton du menu
if(event.button.x >= 54 && event.button.x <= 393) {
if(event.button.y >= 435 && event.button.y <= 446) {
//Option
affiche = true;

}
}

//Si on clique sur le dernier bouton du menu
if(event.button.x >= 54 && event.button.x <= 293) {
if(event.button.y >= 451 && event.button.y <= 462) {
//Quitter
exit(EXIT_SUCCESS);
}
}
}
}

//Affichage
if(affiche) {
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 244, 249, 253));
menu.afficher(ecran);

affiche = false;
}

SDL_Flip(ecran);
}
}

Il y a le main(qui est assez petit) et la boucle principale juste en dessous

Vient maintenant le jeu.cpp :

#include <string>

#include "ClassImage.h"

#include "jeu.h"
#include "constantes.h"

bool jeuApprentissage(SDL_Surface* ecran, int difficulter) {
//Difficulter :
//1 = Facile
//2 = Moyen
//3 = Difficile

Image imgApprentissage(1, 4, "data/images/apprentissage.png");

bool affiche = true;

SDL_Event event;
while(SDL_WaitEvent(&event)) {
if(event.type == SDL_QUIT) exit(EXIT_SUCCESS);

//Si il y a un clique de souris
if(event.type == SDL_MOUSEBUTTONUP) {
//Si c'est un clique gauche
if(event.button.button = SDL_BUTTON_LEFT) {
//Si on clique sur le bouton
if(event.button.x >= 14 && event.button.x <= 170) {
if(event.button.y >= 562 && event.button.y <= 576) {
jeuParcourEssaie(ecran, 1);
affiche = true;
return true;
}
}
}
}

//Affichage
if(affiche) {
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 244, 249, 253));
imgApprentissage.afficher(ecran);

affiche = false;
}

SDL_Flip(ecran);
}
}
bool jeuParcourEssaie(SDL_Surface* ecran, int difficulter) {
SDL_EnableKeyRepeat(10, 10);

Image imgParcourEssaie(-1, 25, "data/images/parcourEssai.png");
Image zozor[2], zozor2[2], zozorActuel, pacman(343, 227, "data/images/pacman.png");
zozor[0].setAll(74, 337, "data/images/zozorG.png");
zozor[1].setAll(74, 337, "data/images/zozorD.png");
zozorActuel = zozor[1];

bool afficher = true;

SDL_Event event;
while(SDL_WaitEvent(&event)) {
if(event.type == SDL_QUIT) exit(EXIT_SUCCESS);

//Si il y a un clique de souris
if(event.type == SDL_MOUSEBUTTONUP) {
//Si c'est un clique gauche
if(event.button.button = SDL_BUTTON_LEFT) {
//Si on clique sur le bouton
if(event.button.x >= 10 && event.button.x <= 81) {
if(event.button.y >= 541 && event.button.y <= 551) {
return true;
}
}
}
}

//Si on appuie sur une touche
if(event.type == SDL_KEYDOWN) {
//Si on appuie sur la bouton gauche
if(event.key.keysym.sym == SDLK_LEFT) {
zozorActuel = zozor[0];
zozorActuel.setPositionX(zozorActuel.getPositionX() - 1);
zozor[0].setPositionX(zozorActuel.getPositionX());
zozor[1].setPositionX(zozorActuel.getPositionX());

afficher = true;
}

//Si on appuie sur la bouton droit
if(event.key.keysym.sym == SDLK_RIGHT) {
zozorActuel = zozor[1];
zozorActuel.setPositionX(zozorActuel.getPositionX() + 1);
zozor[0].setPositionX(zozorActuel.getPositionX());
zozor[1].setPositionX(zozorActuel.getPositionX());

afficher = true;
}

//Si on appuie sur la bouton haut
if(event.key.keysym.sym == SDLK_UP) {

}

//Si on appuie sur la bouton bas
if(event.key.keysym.sym == SDLK_DOWN) {

}

//Si on appuie sur la bouton entrer
//if(event.key.keysym.sym == SDLK_ENTER) {

//}
}

//Affichage
if(afficher) {
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 244, 249, 253));
imgParcourEssaie.afficher(ecran);
pacman.afficher(ecran);
zozorActuel.afficher(ecran);

afficher = false;
}
SDL_Flip(ecran);
}
}

La les deux fonction ont chacune une boucle d'evenement(la premiere appelle la seconde).

Je pense pas que j'ai besoin de mettre jeu.h

la class fenetre est une simple class qui créé la fenetre.
La class Image est une class qui permet de blitté des images(qui peuvent être répété).

Je pense que c'est tout pour les explication car le code est très simple.

Anonyme

9 juillet 2007 à 21:04:31

Dans l'état actuel, j'ai dû mal à voir une quelconque fuite :euh:

. Bien sûr, c'est en se basant sur le fait que la classe Image gère correctement ses ressources.
Par ailleurs, des images de 800*650 ne devrait pas surcharger ton ordinateur...
Je crois que là, désolé, je vais laisser la place à d'autres :honte:

int21h

9 juillet 2007 à 21:57:58

if(event.type == SDL_QUIT) exit(EXIT_SUCCESS);

Roulez jeunesse, si tu sortais proprement au lieu de sortir comme un cochon, ça se passerait peut être mieux

Mettre à jour le MinGW Gcc sur Code::Blocks. Du code qui n'existe pas ne contient pas de bug

EPonix

10 juillet 2007 à 9:54:41

Bonjour tout le monde et merci de vos réponses,

Citation : Cyprien_

Par ailleurs, des images de 800*650 ne devrait pas surcharger ton ordinateur...

Je blitte les images seulement quand il y a un eu un changemet qui a pu changé l'image.

int21h : comment peut on sortir proprement? Est-ce que ça marcherais si je desait que en retournant false, je quitte et en retournant true je reste?

Il y a toujours le même probème même si le jeu est maintenant assez fluide.
Voici la class Image(je pense que ça sert a rien de mettre toutes les methodes getQqch et setQqch):
ClassImage.h

#ifndef IMAGE

#define IMAGE

#include <iostream>

#include <SDL/SDL.h>

#include <SDL/SDL_image.h>

class Image

{

private:

SDL_Surface* m_Surface;

SDL_Surface* m_VSurface;

SDL_Rect m_Position;

std::string m_CheminSurface;

int m_NbrRepeatX;

int m_NbrRepeatY;

int m_Alpha;

public:

Image();

Image(std::string cheminSurface, int positionX = 0, int positionY = 0, int nbrRepeatX = 1, int nbrRepeatY = 1, int alpha = 255);

~Image();

SDL_Surface* getSurface();

SDL_Surface* getRealSurface();

SDL_Rect getPosition();

std::string getCheminImage();

int getPositionX();

int getPositionY();

int getNbrRepeatX();

int getNbrRepeatY();

int getAlpha();

void setAll(std::string cheminSurface, int positionX = 0, int positionY = 0, int nbrRepeatX = 1, int nbrRepeatY = 1, int alpha = 255);

void setSurface(std::string cheminSurface);

void setPosition(int positionX, int positionY);

void setPositionX(int positionX);

void setPositionY(int positionY);

void setNbrRepeat(int nbrRepeatX, int nbrRepeatY);

void setNbrRepeatX(int nbrRepeatX);

void setNbrRepeatY(int nbrRepeatY);

void setAlpha(int alpha);

void afficher(SDL_Surface* ecran);

};

#endif

Voici ClassImage.cpp :

#include "ClassImage.h"

#include <iostream>

#include <SDL/SDL.h>

#include <SDL/SDL_image.h>

/*-----------------------Contructeur et destructeur-------------------------*/

Image::Image() {

m_Surface = NULL;

m_VSurface = NULL;

m_Position.x = 0;

m_Position.y = 0;

m_NbrRepeatX = 1;

m_NbrRepeatY = 1;

m_Alpha = 255;

m_CheminSurface = "";

}

Image::Image(std::string cheminSurface, int positionX, int positionY, int nbrRepeatX, int nbrRepeatY, int alpha) {

m_Position.x = positionX;

m_Position.y = positionY;

m_NbrRepeatX = nbrRepeatX;

m_NbrRepeatY = nbrRepeatY;

m_Alpha = alpha;

m_CheminSurface = cheminSurface;

m_Surface = IMG_Load(m_CheminSurface.c_str());

if(m_Surface == NULL) {

std::cout << "Impossible d'ouvrir " << m_CheminSurface << ". Fermeture du programme!" << std::endl;

exit(EXIT_FAILURE);

}

SDL_Rect position;

position.x = 0;

position.y = 0;

m_VSurface = SDL_CreateRGBSurface(SDL_HWSURFACE, m_Surface->w * m_NbrRepeatX, m_Surface->h * m_NbrRepeatY, 32, 0, 0, 0, 0);

for(int i = 0 ; i <= m_NbrRepeatX - 1 ; i++) {

for(int j = 0 ; j <= m_NbrRepeatY - 1 ; j++) {

SDL_BlitSurface(m_Surface, NULL, m_VSurface, &position);

position.y += m_Surface->h;

}

position.x += m_Surface->w;

position.y = 0;

}

SDL_SetAlpha(m_VSurface, SDL_SRCALPHA, m_Alpha);

}

Image::~Image() {

SDL_FreeSurface(m_Surface);

SDL_FreeSurface(m_VSurface);

}

/*-----------------------------Methode type getQqch--------------------*/

/*-----------------------------Methode type setQqch--------------------*/
void Image::setAll(std::string cheminSurface, int positionX, int positionY, int nbrRepeatX, int nbrRepeatY, int alpha) {

m_Position.x = positionX;

m_Position.y = positionY;

m_NbrRepeatX = nbrRepeatX;

m_NbrRepeatY = nbrRepeatY;

m_Alpha = alpha;

m_CheminSurface = cheminSurface;

m_Surface = IMG_Load(m_CheminSurface.c_str());

if(m_Surface == NULL) {

std::cout << "Impossible d'ouvrir " << m_CheminSurface << ". Fermeture du programme!" << std::endl;

exit(EXIT_FAILURE);

}

SDL_Rect position;

position.x = 0;

position.y = 0;

m_VSurface = SDL_CreateRGBSurface(SDL_HWSURFACE, m_Surface->w * m_NbrRepeatX, m_Surface->h * m_NbrRepeatY, 32, 0, 0, 0, 0);

for(int i = 0 ; i <= m_NbrRepeatX - 1 ; i++) {

for(int j = 0 ; j <= m_NbrRepeatY - 1 ; j++) {

SDL_BlitSurface(m_Surface, NULL, m_VSurface, &position);

position.y += m_Surface->h;

}

position.x += m_Surface->w;

position.y = 0;

}

SDL_SetAlpha(m_VSurface, SDL_SRCALPHA, m_Alpha);

}

void Image::setSurface(std::string cheminSurface) {

m_CheminSurface = cheminSurface;

m_Surface = IMG_Load(m_CheminSurface.c_str());

SDL_FreeSurface(m_VSurface);

SDL_Rect position;

position.x = 0;

position.y = 0;

m_VSurface = SDL_CreateRGBSurface(SDL_HWSURFACE, m_Surface->w * m_NbrRepeatX, m_Surface->h * m_NbrRepeatY, 32, 0, 0, 0, 0);

for(int i = 0 ; i <= m_NbrRepeatX - 1 ; i++) {

for(int j = 0 ; j <= m_NbrRepeatY - 1 ; j++) {

SDL_BlitSurface(m_Surface, NULL, m_VSurface, &position);

position.y += m_Surface->h;

}

position.x += m_Surface->w;

position.y = 0;

}

}

/*------------------------------Methodes Diverses----------------------*/

void Image::afficher(SDL_Surface* ecran) {

SDL_BlitSurface(m_VSurface, NULL, ecran, &m_Position);

}

J'ai un autre problème : ma méthode ne peux afficher correctement que les rectangles. Car pour plus de vitesse, je blittent toutes les images à répété sur une seule surface, puis pour l'affichage, je blittent la grande surface.
La grande surface est par défaut noir(ou une autre couleur) mais si je blittent un rond, il y aura des coins noirs.

Sauriez vous comment ne pas afficher ce noir?
J'ai essayé de mettre SDL_SetColor mais j'ai du texte qui est en noir sur l'image est il s'efface.

Merci d'avance

magnanime

10 juillet 2007 à 10:01:29

Si appellais la fonction atexit() avant exit() ça serait plus propre.

EPonix

10 juillet 2007 à 10:20:45

Pourrait tu m'éclairer sur la manière de l'utiliser car je vois vraiment pas comment.

neuneutrinos

10 juillet 2007 à 10:56:07

Citation : Pas de titre

if(event.type == SDL_QUIT) exit(EXIT_SUCCESS);

ca ne quittera jamais!!! car
EXIT_SUCCESS =0
EXIT_FAILURE =1

mais quos qu'il en soit il faut reserver exit() en cas d'erreur
du genre

SDL_Surface *surface=NULL;
surface=IMG_Load("image.bmp");
if(surface==NULL)
exit(1);//ou EXIT_FAILURE

Nanoc

10 juillet 2007 à 11:10:30

Ou encore mieux, ne pas utiliser de exit() du tout. C'est moche et ça ne s'utilise que quand on peut pas faire autrement. C'est une fonction "héritée" du C et en C++, il y a de quoi faire sans. (En C aussi d'ailleurs)

Citation : The French

int21h : comment peut on sortir proprement? Est-ce que ça marcherais si je disait que en retournant false, je quitte et en retournant true je reste?

Oui exactement. Tu déclares un booléen quelque part que tu mets à true. Et tu fais ta boucle principale tant que ce booléen est à true. Ensuite pour quitter, tu le mets à false, ce qui termine la boucle principale et exécute le code se trouvant après. (Chose qui n'est pas faite en utilisant exit). Tu peux ainsi quitter l'application proprement.

Une autre solution serait d'utiliser la gestion des exceptions avec des bloc try{} - catch(){}

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

EPonix

10 juillet 2007 à 11:17:40

Merci

Donc j'ai refait le code :
- le while(SDL_WaitEvent(&event) devient while(continuer)
- les exit() se transforme en return false;
- pour venir dans la boucle d'avant je fait continuer = false et a la fin je met return true; (false = quit ; true = reste)

Mais j'ai toujour le problème de vidange mémoire. et aussi celui pour enlever le noir a cause de ma classe

Il y a ça :

*** glibc detected *** ./executable: double free or corruption (!prev): 0x08074070 ***

Savez vous pourquoi mon ordinateur dit que mon executable est (double free c'est pas double gratuit??) corrompu??

Nanoc

10 juillet 2007 à 11:36:48

free ne veut pas seulement dire gratuit

en anglais to free veut dire libérer. Tu as donc une libération de mémoire qui se fait 2 fois. Comme si tu faisais 2 delete de la même variable ou un SDL_FreeSurface exécuté 2 fois sur la même surface.

Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.

EPonix

10 juillet 2007 à 12:08:54

Alors je sais d'ou vient le problème (merci beaucoup de la traduction).

je dis que zozorActuel = zozor[1];. Faudrait donc que je change ça dans ma classe.

J'ai essayé mais j'ai toujours l'erreur

Voici mon contructeur de copie :

Image::Image(const Image &imageACopier) {
m_Position.x = imageACopier.m_Position.x;
m_Position.y = imageACopier.m_Position.y;
m_NbrRepeatX = imageACopier.m_NbrRepeatX;

m_NbrRepeatY = imageACopier.m_NbrRepeatY;

m_Alpha = imageACopier.m_Alpha;

m_CheminSurface = imageACopier.m_CheminSurface;

m_Surface = IMG_Load(m_CheminSurface.c_str());
if(m_Surface == NULL) {

std::cout << "Impossible d'ouvrir " << m_CheminSurface << ". Fermeture du programme!" << std::endl;

exit(EXIT_FAILURE);

}

SDL_Rect position;

position.x = 0;

position.y = 0;

m_VSurface = SDL_CreateRGBSurface(SDL_HWSURFACE, m_Surface->w * m_NbrRepeatX, m_Surface->h * m_NbrRepeatY, 32, 0, 0, 0, 0);

for(int i = 0 ; i <= m_NbrRepeatX - 1 ; i++) {

for(int j = 0 ; j <= m_NbrRepeatY - 1 ; j++) {

SDL_BlitSurface(m_Surface, NULL, m_VSurface, &position);

position.y += m_Surface->h;

}

position.x += m_Surface->w;

position.y = 0;

}

SDL_SetColorKey(m_VSurface, SDL_SRCCOLORKEY, SDL_MapRGB(m_VSurface->format, 0, 0, 0));

SDL_SetAlpha(m_VSurface, SDL_SRCALPHA, m_Alpha);
}

Est-ce que vous savez d'ou ça peut venir?

Merci d'avance

EDIT : en faite faut faire une surcharge d'opérateur=. Mais est-ce que c'est seulement le prototype qui changent?

int21h

10 juillet 2007 à 13:43:45

Citation : The French

int21h : comment peut on sortir proprement? Est-ce que ça marcherais si je desait que en retournant false, je quitte et en retournant true je reste?

Par exemple, tu n'es pas non plus obligé de retourner un bool, tu peux aussi retourner un int et décider quoi faire en fonction de la valeur de retour, ceci pourra être utile pour par exemple gérer des enchainements de menu ou de phase de jeu. Par exemple tu peux retourner 0 sur le SDL_QUIT, 1 pour revenir sur un menu, et une valeur négative en cas d'erreur (la valeur dépend de l'erreur). De cette manière tu pourras avoir une gestion beaucoup plus fine, et sortir en étant bien sûr que tu as tout fermé et tout libéré.

Quand tu appelles exit ou abort, tu sors direct, tu ne libère rien, les destructeurs ne sont pas appelés, les fichiers ouverts sont fermés d'autorité par l'OS (ce qui peut les rendre inutilisables), c'est vraiment à réserver pour les arrêts d'urgence.

D'une manière générale, l'exit est destiné à sortir uniquement des erreurs vraiment irrécupérables, n'utilise exit ou abort que si tu te trouves dans un cas d'erreur tellement grave que tu ne sois plus en mesure de sortir à peu près proprement, dans les cas où tu risques de faire plus de dégats en continuant qu'en t'arrêtant tout de suite (ce qui n'arrive pratiquement jamais, si tu gères correctement les erreurs et les exceptions). Je maintiens un programme qui approche les 100000 lignes de code, dedans il n'y a qu'un seul exit, qui ne survient qu'en cas de défaillance d'un composant électronique, cette défaillance compromet tout le reste, et risque de compromettre des données vitales pour le programme si je continue, donc il faut tout arrêter immédiatement si le problème se présente, c'est le seul cas qui justifie l'utilisation d'exit ou d'abort.

Mettre à jour le MinGW Gcc sur Code::Blocks. Du code qui n'existe pas ne contient pas de bug

EPonix

10 juillet 2007 à 14:51:28

Merci j'ai un peu changé le code.

Maintenant le retour en arriere(ça se dit??

) fonctionne.
Mais il restent encore une chose qui ne fonctionne pas : comment faire pour remplir un espace de transparent? Je parle que d'un bout(sans SDL_SetAlpha)