Partage
  • Partager sur Facebook
  • Partager sur Twitter

Problème de fuite de mémoire

(encore et toujours..... )

Sujet résolu
77Arthur77
    18 juin 2007 à 11:22:53

    Bon je vous prévien tout de suite, mais expérimentant les héritages en c++, mon code et très gros et se répètte assez souvent...
    Mais voilà je n'arrive pas à le compiler, mon compilateur me dit:
    Process terminated with status 1 (0 minutes, 0 seconds)
    0 errors, 0 warnings

    Et avec ma grande expérience des méssages d'erreurs ( :D , je crois que je passe plus de temps à lire les méssages d'erreur que de tester mes programmes) j'en ai déduis qu'il y avait une fuite de mémoir quelque part (à chaque fois que mon compilateur me disait ça, s'en était la cause).
    J'ai eu beau chercher, des heures et des heures en me répettant dans ma tête: il faut que je trouve tout seul!! tu vas bien résoudre un jour tout seul un de tes problème quand même!!
    Rien à faire, le problème persiste....
    Bon bas je vous met mon code, peut être qu'a ne pas dormir la nuit, je n'ai pas vue ce qui va vous crevez les yeux.

    Le main.cpp
    #include <iostream>
    #include <string>
    #include <SDL/SDL.h>
    #include <SDL/SDL_Image.h>
    #include <SDL/SDL_ttf.h>
    #include "PersonnageGame.h"




    using namespace std;

    int main(int argc, char *argv[])
    {
      SDL_Event event;
      int continuer=1, m=0;
      SDL_Surface*ecran;
      SDL_Rect positionRot;

      /* initialisation de la SDL*/
      SDL_Init(SDL_INIT_VIDEO);
      SDL_WM_SetCaption("   Test c++ et classe SDL  ", NULL);
      SDL_WM_SetIcon(IMG_Load("nuinui4.png"), NULL);
      ecran = SDL_SetVideoMode( 1000  ,  800  , 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
      SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));


      /*création des  objets de type PersonnageG*/
      PersonnageG monPerso(ecran);

      int a= (int)monPerso.getPosition().x;
      int b= (int)monPerso.getSurface()->w;
      int c= (int)monPerso.getPosition().y;
      int d= (int)monPerso.getSurface()->h/2;

      PersonnageG missile(monPerso.getEcran(), 30, a+b, c+d);
      monPerso.setImage("vaisseau.bmp");
      monPerso.setTrans('C', 255, 255, 255);

      missile.setImage("powerbowl.gif");
      missile.setTrans('C', 0, 0, 0);
      missile.StartTime();

    SDL_EnableKeyRepeat(10, 10);

    while (continuer)
    {
        SDL_PollEvent(&event);
         switch(event.type)
            {
                case SDL_QUIT:
                    continuer = 0;
                    break;

                case SDL_KEYDOWN  :
                if (event.key.keysym.sym == SDLK_UP || SDLK_DOWN ||SDLK_LEFT || SDLK_RIGHT)
                monPerso.VERMOUV(event);
                switch (event.key.keysym.sym)
                      {
                        case SDLK_ESCAPE:
                        continuer=0;
                        break;

                        case SDLK_SPACE:
                        m=1;
                        break;
                    }
            }
            SDL_FillRect (ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
            monPerso.affiche();
            if(m)
            {
            missile.LDROITE();
            missile.affiche();
            }
            SDL_Flip (ecran);
    }
        SDL_Quit();
        return EXIT_SUCCESS;
    }





    le PersonnageG.h
    #ifndef DEF_PERSOGAME
    #define DEF_PERSOGAME

    #include "Personnage.h"
    #include "SDLG.h"
    #include "Time.h"
    #include <SDL/SDL.h>

    class PersonnageG: protected Personnage, protected SDL_Game
    {
        Timer *YA;


        public:
        PersonnageG(SDL_Surface *ecran=NULL ,int t=0, int x=0, int y=0): SDL_Game(ecran, x, y)
        {
            YA=new Timer(t);
        }


         /*Setting*/
         void setImage(const char *);
         void setTrans(char, long=0, long=0, long=0);//changer la transaparence
         void affiche();

        /*Non visuel ->Personnage*/
        void recevoirDegats(int nbDegats);
        void attaquer(PersonnageG &cible);
        bool estVivant();


        /* SDL, visuel->SDL_Game*/
       void GAUCHE();
       void DROITE();
       void HAUT();
       void BAS();
       SDL_Rect getPosition() const;
       SDL_Surface* getSurface() const;
       SDL_Surface* getEcran() const;


       void StartTime();
       void LDROITE();

       void VERMOUV(SDL_Event);
       void BLOC();
       void UNBLOC();


       ~PersonnageG()
       {
           delete YA;
       }
    };


    #endif


    le PersonnageG.cpp
    #include <iostream>
    #include <string>
    #include <SDL/SDL.h>
    #include <SDL/SDL_Image.h>
    #include <SDL/SDL_ttf.h>
    #include "PersonnageGame.h"


    using namespace std;

    void PersonnageG::setImage(const char *nom)
    {
        setImageG(nom);
    }
    void PersonnageG::setTrans(char a, long b, long c, long d)//changer la transaparence
    {
        setTransG(a, b, c, d);
    }

    void PersonnageG::affiche()
    {
        afficheG();
    }

        /*Non visuel ->Personnage*/
    void PersonnageG::recevoirDegats(int nbDegats)
    {
        recevoirDegatsP(nbDegats);
    }
    void PersonnageG::attaquer(PersonnageG &cible)
    {
        attaquerP(cible);
    }
    bool PersonnageG::estVivant()
    {
        return estVivantP();
    }
        /* SDL, visuel->SDL_Game*/
    void PersonnageG::GAUCHE()
    {
        allerGG();
    }
    void PersonnageG::DROITE()
    {
        allerDG();
    }
    void PersonnageG::HAUT()
    {
        allerHG();
    }
    void PersonnageG::BAS()
    {
        allerBG();
    }

    void PersonnageG::VERMOUV(SDL_Event event)
    {
        switch (event.key.keysym.sym)
                {
                    case SDLK_LEFT:
                    GAUCHE();
                    break;

                    case SDLK_RIGHT:
                    DROITE();
                    break;

                    case SDLK_UP:
                    HAUT();
                    break;

                    case SDLK_DOWN:
                    BAS();
                    break;
                }

    }

    void PersonnageG::BLOC()
    {
        bloqueG();
    }

    void PersonnageG::UNBLOC()
    {
        unBloqueG();
    }

    void PersonnageG::LDROITE()
    {
       if (YA->GetTicks())
       DROITE();
    }

    void PersonnageG::StartTime()
    {
        YA->start();
    }

    SDL_Rect PersonnageG::getPosition() const
    {
      return getPos();
    }

    SDL_Surface* PersonnageG::getSurface() const
    {
        return getSur();
    }

    SDL_Surface* PersonnageG::getEcran() const
    {
        return getEc();
    }



    Le SDLG.h
    #ifndef DEF_GAME
    #define DEF_GAME

    #include <SDL/SDL.h>
    #include "SDL.h"


    class  SDL_Game: public SDL
    {
       bool m_unbloque;
       int a, b;


       public:
       SDL_Game(SDL_Surface*ecran=NULL, long x=0, long y=0): SDL(ecran, x, y)
       {
            bool m_unbloque=true;
            a=0;
            b=0;
       }
      /*Nouveau*/
       void allerGG();
       void allerDG();
       void allerHG();
       void allerBG();
       void VerAllerG(SDL_Event);
       void bloqueG();
       void unBloqueG();
       SDL_Rect getPos() const;
       SDL_Surface* getSur() const;
       SDL_Surface* getEc() const;

       /*Ancien*/
       void setImageG(const char *);
       void setTransG(char, long=0, long=0, long=0);//changer la transaparence
       void setTexteG(const char*, const char*, long);
       void afficheG();



       ~SDL_Game(){}
    };

    #endif


    le SDLG.cpp
    #include <iostream>
    #include <string>
    #include <SDL/SDL.h>
    #include <SDL/SDL_Image.h>
    #include <SDL/SDL_ttf.h>
    #include "SDLG.h"


    using namespace std;

    void SDL_Game::allerGG()
    {
        setPos(a-=2, b);
    }

    void SDL_Game::allerDG()
    {
        setPos(a+=2, b);
    }

    void SDL_Game::allerHG()
    {
        setPos(a, b-=2);
    }

    void SDL_Game::allerBG()
    {
        setPos(a, b+=2);
    }

    void SDL_Game::VerAllerG(SDL_Event event)
    {
        if (m_unbloque)
        {
        switch (event.key.keysym.sym)
                {
                    case SDLK_LEFT:
                    allerGG();
                    break;

                    case SDLK_RIGHT:
                    allerDG();
                    break;

                    case SDLK_UP:
                    allerHG();
                    break;

                    case SDLK_DOWN:
                    allerBG();
                    break;
                }
        }
    }

    void SDL_Game::bloqueG()
    {
        m_unbloque=false;
    }

    void SDL_Game::unBloqueG()
    {
        m_unbloque=true;

    }

    void SDL_Game::setImageG(const char* nom)
    {
        setNom(nom);
    }

    void SDL_Game::setTransG(char a, long b, long c, long d)
    {
        if (a=='C')
        setTransC(b, c, d);
        else if (a=='A')
        setTransA(b);
    }

    void SDL_Game::setTexteG(const char*message, const char*police, long taille)
    {
        setTexteS(message, police, taille);
    }

    void SDL_Game::afficheG()
    {
        afficheS();
    }

    SDL_Rect SDL_Game::getPos() const
    {
        return getPositionS();
    }

    SDL_Surface* SDL_Game::getSur() const
    {
        return getSurfaceS();
    }

    SDL_Surface* SDL_Game::getEc() const
    {
        return getEcranS();
    }



    Le SDL.h
    #ifndef DEF_GAME
    #define DEF_GAME

    #include <SDL/SDL.h>
    #include "SDL.h"


    class  SDL_Game: public SDL
    {
       bool m_unbloque;
       int a, b;


       public:
       SDL_Game(SDL_Surface*ecran=NULL, long x=0, long y=0): SDL(ecran, x, y)
       {
            bool m_unbloque=true;
            a=0;
            b=0;
       }
      /*Nouveau*/
       void allerGG();
       void allerDG();
       void allerHG();
       void allerBG();
       void VerAllerG(SDL_Event);
       void bloqueG();
       void unBloqueG();
       SDL_Rect getPos() const;
       SDL_Surface* getSur() const;
       SDL_Surface* getEc() const;

       /*Ancien*/
       void setImageG(const char *);
       void setTransG(char, long=0, long=0, long=0);//changer la transaparence
       void setTexteG(const char*, const char*, long);
       void afficheG();



       ~SDL_Game(){}
    };

    #endif


    Le SDL.cpp
    #include <iostream>
    #include <string>
    #include <SDL/SDL.h>
    #include <SDL/SDL_Image.h>
    #include <SDL/SDL_ttf.h>

    #include "SDL.h"

    using namespace std;

    SDL::SDL (SDL_Surface*ecran1 ,long x, long y)
    {
            ecran=ecran1;
            m_nom="";
            m_x=x;
            m_y=y;
            m_t=false;
            m_tA=false;
            m_setTransA=0;
            m_setTransC[3]=0;
            m_color= false;
            m_setColor[3]=0;
            m_texte=false;
            m_surface=NULL;
            m_message=NULL;
            m_police =NULL;
            m_taille=0;
            police1=NULL;
            position.x=m_x;
            position.y=m_y;
    }

    void SDL::setNom(const char *nom)//changer le nom
    {
        SDL_FreeSurface (m_surface);
        m_color=false;
        m_texte=false;
        m_nom=nom;
        m_surface=IMG_Load(m_nom);
    }


    void SDL::setPos (long x=0,long y=0)//changer la position
    {
        m_x=x;
        m_y=y;
    }


    void SDL::setTransC(long a, long b, long c)//changer la transaparence
    {
           m_t=true;
           m_tA=false;

           m_setTransC[0]= a;
           m_setTransC[1]= b;
           m_setTransC[2]= c;

    }

    void SDL::setTransA(long a)// changer la transparence alpha
    {
        m_t=false;
        m_tA=true;

        m_setTransA=a;
    }

    void SDL::setColor(long a, long b, long c)//changer la couleur
    {
        m_color=true;

        m_setColor[0]= a;
        m_setColor[1]= b;
        m_setColor[2]= c;
    }

    void SDL::setTexteS(const char* message, const char* police, long taille)
    {
        TTF_CloseFont (police1);
        m_texte=true;
        m_message=message;
        m_police=police;
        m_taille=taille;
    }

    void SDL::afficheS()
    {
       if(!m_texte)
       {
        position.x=m_x;
        position.y=m_y;
        if (m_t)
        {
        SDL_SetColorKey(m_surface , SDL_SRCCOLORKEY, SDL_MapRGB( m_surface ->format, m_setTransC[0], m_setTransC[1], m_setTransC[2]));
        }
        else if (m_tA)
        {
        SDL_SetAlpha(m_surface, SDL_SRCALPHA, m_setTransA);
        }
        SDL_BlitSurface(m_surface, NULL, ecran, &position);
       }
       else
        {
        SDL_Rect position;
        SDL_Color couleur = {m_setColor[0], m_setColor[1], m_setColor[2]};
        police1 = TTF_OpenFont(m_police, m_taille);
        m_surface = TTF_RenderText_Blended(police1, m_message , couleur);
        SDL_BlitSurface(m_surface, NULL, ecran, &position);
        }
    }

    SDL_Rect SDL::getPositionS() const
    {
        return position;
    }

    SDL_Surface* SDL::getSurfaceS() const
    {
        return m_surface;
    }

    SDL_Surface* SDL::getEcranS() const
    {
        return ecran;
    }

     SDL::~SDL()//pour libérer la surface;
    {
      SDL_FreeSurface (m_surface);
      SDL_FreeSurface (ecran);
      if (m_texte)
      TTF_CloseFont(police1);
    }



    Et enfin la dernière classe
    Le Timer.h
    #ifndef DEF_TIME
    #define DEF_TIME

    //Le Timer
    class Timer
    {
        private:
        //Le temps quand le timer est lancé
        int startTicks;

        //Le temps enregistré quand le Timer a été mis en pause
        int pausedTicks;

        //Le status du Timer
        bool paused;
        bool started;

        int intervalle;

        public:
        //Initialise les variables
        Timer(int);



        //Les différentes actions du timer
        void start();
        void pause();
        void unPause();
        //recupére le nombre de millisecondes depuis que le timer a été lancé
        //ou récupére le nombre de millisecondes depuis que le timer a été mis en pause
        bool GetTicks();

        //Fonctions de vérification du status du timer
        bool is_started();
        bool is_paused();
        ~Timer(){};
    };




    #endif


    et le Timer.cpp

    #include <iostream>
    #include <string>
    #include <SDL/SDL.h>
    #include <SDL/SDL_Image.h>
    #include <SDL/SDL_ttf.h>
    #include "Time.h"

    using namespace std;

    Timer::Timer(int intervalle1): startTicks(0), pausedTicks(0), paused(false), started(false), intervalle(intervalle1)
    {
    }

    void Timer::start()
    {
        started=true;
        paused=false;
        startTicks=SDL_GetTicks();
    }

    bool Timer::GetTicks()
    {
        if (started)
        {
            if (paused)
              return pausedTicks;
            else
             {
              if (SDL_GetTicks()-startTicks> intervalle)
              {
              return true;
              }
              else
              {
              return false;
              }
              startTicks=SDL_GetTicks();
             }
        }
        return false;
    }


    void Timer::pause()
    {
        paused=true;
    }

    void Timer::unPause()
    {
        paused=false;
    }

    bool Timer::is_started()
    {
        return started;
    }

    bool Timer::is_paused()
    {
        return paused;
    }


    Désolé pour tout ce code, mais ne connaissant pas où exactement il y avait le problème.....
    Merci de toute l'attention que vous porterez à mon problème.

    Ps:la classe Personnage.cpp et .h est la même que celle du cour de matéo sans la classe Arme.

    • Partager sur Facebook
    • Partager sur Twitter
    Anonyme
      18 juin 2007 à 12:04:16

      Ici:
      police1 = TTF_OpenFont(m_police, m_taille);
          m_surface = TTF_RenderText_Blended(police1, m_message , couleur);


      Tu ne libères pas la police ouverte et la surface créée.
      Solution: soit tu libères juste après, mais comme ce sera fait à chaque frame, ça risque de ralentir ton programme.
      Soit tu ne crées cette surface et n'ouvre cette police qu'une seule fois, dans le constructeur, puis tu les libères dans le destructeur. Dans ce cas, il faut aussi prévoir le cas où tu changes de texte ou de police: tu libères la surface/la police avant d'en recréer une autre (dans la méthode setTexteS).
      • Partager sur Facebook
      • Partager sur Twitter
      77Arthur77
        18 juin 2007 à 12:15:51

        Je doit dire une bétise mais en faisant

        Citation : 77Arthur77

        void SDL::setTexteS(const char* message, const char* police, long taille)
        {
        TTF_CloseFont (police1);

        je ne libère pas la mémoire e police1?
        PS: désolé mais erreur de manip, j'ai remis SDLG.h au lieu de SDL.h.

        EDIT: voici le vraie SDL.h
        #ifndef DEF_SDL
        #define DEF_SDL

        class SDL
        {
            public:
            SDL (SDL_Surface* ecran=NULL,long x=0, long y=0);//constructeur

            void setNom(const char *);//changer le nom
            void setPos (long,long);//changer la position
            void setTransC(long, long, long);//changer la transaparence
            void setTransA(long);// changer la transparence alpha
            void setColor(long, long, long);//changer la couleure
            void setTexteS(const char*, const char*, long);
            void afficheS();
            SDL_Rect getPositionS() const;
            SDL_Surface* getSurfaceS() const;
            SDL_Surface* getEcranS() const;
            ~SDL();



            protected:
            //position
            long m_x, m_y;

            //transparence
            bool m_t, m_tA;
            long m_setTransA;
            long m_setTransC[3];

           //couleur et contenue
            bool m_color;
            long m_setColor [3];
            const char *m_nom;

            //texte
             bool m_texte;
             const char*m_message;
             const char*m_police;
             long m_taille;

             //Surface
             SDL_Surface *ecran;
             SDL_Surface *m_surface;
             TTF_Font *police1;
             SDL_Rect position;
        };


        #endif
        .

        Je vien de me rendre compte d'une erreur toute bêtes, j'avais oublié de faire TTF_Init() et TTF_Quit()...
        Je les ais rajouté dans le main, mais rien à faire, j'ai toujours la même erreur. :(
        • Partager sur Facebook
        • Partager sur Twitter
        Anonyme
          18 juin 2007 à 13:27:35

          D'ailleurs oui, tu libères police1, mais tu ne l'a jamais ouverte si tu n'as pas encore appelé afficheS().
          A part ça, effectivement, tu libères la police, mais seulement quand tu changes le texte. Or, à chaque affichage tu réouvres la police et tu recrées une surface avec TTF_Render... et tu ne libères jamais cela.
          • Partager sur Facebook
          • Partager sur Twitter
          77Arthur77
            18 juin 2007 à 14:56:51

            1 J'initialise la police dans le constructeur de SDL
            police1=TTF_OpenFont(m_police, m_taille);


            2 Je désalloue la mémoire dans le déstructeur SDL
            TTF_CloseFont(police1);


            3 je change la méthode affiche pour qu'elle ne charge plus rien et qu'elle ne désalloue plus rien, juste afficher
            SDL_Rect position;
                SDL_Color couleur = {m_setColor[0], m_setColor[1], m_setColor[2]};
                m_surface = TTF_RenderText_Blended(police1, m_message , couleur);
                SDL_BlitSurface(m_surface, NULL, ecran, &position);


            4 Je change ma méthode setTexteS pour qu'elle désalloue la police, qu'elle change ce qu'elle a à changer et qu'elle recharge la police.
            void SDL::setTexteS(const char* message, const char* police, long taille)
            {
                TTF_CloseFont (police1);
                m_texte=true;
                m_message=message;
                m_police=police;
                m_taille=taille;
                police1 = TTF_OpenFont(m_police, m_taille);
            }


            5 J'initialise et je quite TTF dans le main.
            TTF_Init();
            [...]
            TTF_Quit();




            Ca ne marche toujours pas........(je cours droit à la folie :'( )

            EDIT: je sais pas si ça a de l'importance, mais cette fois ci code blocke me met un peus plus de temps à chaque fois pour compier.
            • Partager sur Facebook
            • Partager sur Twitter
            Anonyme
              18 juin 2007 à 15:06:08

              Citation : 77Arthur77

              3 je change la méthode affiche pour qu'elle ne charge plus rien et qu'elle ne désalloue plus rien, juste afficher

              SDL_Rect position;
                  SDL_Color couleur = {m_setColor[0], m_setColor[1], m_setColor[2]};
                  m_surface = TTF_RenderText_Blended(police1, m_message , couleur);
                  SDL_BlitSurface(m_surface, NULL, ecran, &position);


              Et pourtant, TTF_RenderText_Blended crée une surface, elle n'est toujours pas libérée( au fait, si ça se trouve ton problème ne vient pas de là, c'est juste que tu as demandé les fuites de mémoire, et je te les donne :p ).
              Je viens juste aussi de voir un truc, tu affectes pas mal de chaînes de caractères avec l'opérateur =, or si ce sont des char*, il faut utiliser strcpy. Mais de toute manière, oublie les char*, mieux vaut utiliser std::string.

              Si le problème persiste, essaie de mettre des std::cout partout pour voir où ça plante.
              • Partager sur Facebook
              • Partager sur Twitter
              77Arthur77
                18 juin 2007 à 15:39:31

                Mais, cette surface que TTF_RenderTexte_blended créer, elle est où? Comment fait on pour la désallouer?
                Parceque jusqu'a maintenant je pensait que la seul surface qui était là c'était "m_surface" et qu'on lui attribuait le texte avec la fonction "TTF_RenderTexte_Blended", un peus comme qand on attribut une image à une surface avec "IMG_Load".
                • Partager sur Facebook
                • Partager sur Twitter
                Anonyme
                  18 juin 2007 à 19:05:56

                  Oui, c'est bien ça, donc justement, cette surface que tu lui as "attribué", il faut la libérer avant de lui en attribuer une autre (à chaque appel de TTF_Render, tu crées une nouvelle surface). Donc ton code devrait plutôt ressembler à:
                  SDL_Rect position;
                      SDL_Color couleur = {m_setColor[0], m_setColor[1], m_setColor[2]};
                      m_surface = TTF_RenderText_Blended(police1, m_message , couleur);
                      SDL_BlitSurface(m_surface, NULL, ecran, &position);
                      SDL_FreeSurface(m_surface);

                  Le problème, c'est que ça induit des libérations/créations de surfaces à répétition, donc le mieux serait d'adopter la même méthode que pour la police.

                  Au fait, je ne sais pas si un SDL_FreeSurface(NULL); fait planter l'exécution, il faudrait que tu testes, car quand tu as:
                  void SDL::setNom(const char *nom)//changer le nom
                  {
                      SDL_FreeSurface (m_surface);
                      m_color=false;
                      m_texte=false;
                      m_nom=nom;
                      m_surface=IMG_Load(m_nom);
                  }

                  , si c'est la première utilisation, tu as m_surface==NULL, donc tu fais SDL_FreeSurface(NULL); .
                  Même chose pour la police.
                  • Partager sur Facebook
                  • Partager sur Twitter
                  77Arthur77
                    18 juin 2007 à 21:14:20

                    D'après les conseilles de cyprien_:
                    Voici le constructeur de SDL
                    SDL::SDL (SDL_Surface*ecran1 ,long x, long y)
                    {

                            ecran=ecran1;
                            m_nom="";
                            m_x=x;
                            m_y=y;
                            m_t=false;
                            m_tA=false;
                            m_setTransA=0;
                            m_setTransC[3]=0;
                            m_color= false;
                            m_setColor[3]=0;
                            m_texte=false;
                            m_surface=NULL;
                            m_message=NULL;
                            m_police =NULL;
                            m_taille=0;
                            police1=NULL;
                            position.x=m_x;
                            position.y=m_y;
                            a=0;
                            b=0;
                    }


                    voici la méthode "setNomS"
                    void SDL::setNom(const char *nom)//changer le nom
                    {
                        if (!b)
                        {
                        SDL_FreeSurface (NULL);
                        }
                        else if(b)
                        {
                        SDL_FreeSurface(m_surface);
                        }
                        b=1;
                        m_color=false;
                        m_texte=false;
                        m_nom=nom;
                        m_surface=IMG_Load(m_nom);
                    }


                    voici la méthode setTexteS
                    void SDL::setTexteS(const char* message, const char* police, long taille)
                    {
                        if(!a)
                        {
                        TTF_CloseFont (NULL);
                        }
                        else if (a)
                        {
                        TTF_CloseFont(police1);
                        }

                        a=1;
                        m_texte=true;
                        m_message=message;
                        m_police=police;
                        m_taille=taille;
                        police1 = TTF_OpenFont(m_police, m_taille);

                    }


                    et voici afficheSvoid SDL::afficheS()
                    :
                    void SDL::afficheS()
                    {
                       if(!m_texte)
                       {
                        position.x=m_x;
                        position.y=m_y;
                        if (m_t)
                        {
                        SDL_SetColorKey(m_surface , SDL_SRCCOLORKEY, SDL_MapRGB( m_surface ->format, m_setTransC[0], m_setTransC[1], m_setTransC[2]));
                        }
                        else if (m_tA)
                        {
                        SDL_SetAlpha(m_surface, SDL_SRCALPHA, m_setTransA);
                        }
                        SDL_BlitSurface(m_surface, NULL, ecran, &position);
                       }
                       else
                        {
                        SDL_Rect position;
                        SDL_Color couleur = {m_setColor[0], m_setColor[1], m_setColor[2]};
                        m_surface = TTF_RenderText_Blended(police1, m_message , couleur);
                        SDL_BlitSurface(m_surface, NULL, ecran, &position);
                        }
                    }


                    Et voici le déstructeur:
                    SDL::~SDL()//pour libérer la surface;
                    {
                      SDL_FreeSurface (m_surface);
                      SDL_FreeSurface (ecran);
                      if (m_texte)
                      TTF_CloseFont(police1);
                    }


                    Bon ben, je crois que là, il n'y a vraiment plus de fuite de mémoire. Ca ne marche toujours pas: y a plus qu'a chercher ailleurs. :(
                    • Partager sur Facebook
                    • Partager sur Twitter
                    Anonyme
                      18 juin 2007 à 22:24:31

                      Euh... si tu testes si la police ou la surface ne valent pas NULL, c'est pas pour faire SDL_FreeSurface(NULL) juste après hein, c'est pour ne rien faire :-° .

                      A part ça, ben j'essaierai de tester ton programme dès que j'aurai un bon ordi sous la main ^^ .
                      • Partager sur Facebook
                      • Partager sur Twitter
                      77Arthur77
                        18 juin 2007 à 22:41:12

                        A oui en effet (j'en perd la tête :lol: ). J'ai suprimer les parti :if(!a)
                        {
                        SDL_FreeSurface(NULL);
                        }
                        Bon bas y a toujours la même erreur.
                        Et merci pour ta propose d'aide (j'en peus plus, il faut trop que je le test ce programme: avec, je suis censé pouvoire piloter un avion (en 2d) et lancer un missile!!)
                        Au fait, si tu veus tester le programme, il ne faut pas oublier comme je l'ai dit au début du poste de mettre Personnage.cpp et Personnage.h (les mêmes que dans le cour de Mateo, la classe Arme en moin).
                        • Partager sur Facebook
                        • Partager sur Twitter
                        Anonyme
                          19 juin 2007 à 9:24:02

                          Après test, les lignes qui font planter l'exécution sont les deux-là (pour le moment hein, j'ai pas encore vérifié le reste, je peux difficilement avancer car j'ai pas d'images ^^ ):
                            int b= (int)monPerso.getSurface()->w;

                            int d= (int)monPerso.getSurface()->h/2;


                          Pourquoi ? Parce qu'à ce moment-là, m_surface (renvoyé par getSurface) vaut NULL. Solution: appeler la méthode setImage avant ça.
                          • Partager sur Facebook
                          • Partager sur Twitter
                          77Arthur77
                            19 juin 2007 à 9:51:27

                            :D C'est la fête.

                            C'était bien ça, merci beaucoup maintenant ça marche!(et dire que c'était juste ça...)
                            Bon bas je met mon sujet comme résolu.

                            EDIT: enfin, disons que mon programme s'éxécute (c'est le principale). Il y toujours un truc qui déconne mais bons, je vais essayer m'en charger tout seul.
                            • Partager sur Facebook
                            • Partager sur Twitter

                            Problème de fuite de mémoire

                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                            • Editeur ●
                            • Markdown