Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Allocation dynamique]

J'ai besoin d'aide

Sujet résolu
    9 juin 2007 à 2:58:33

    C'est bon, je m'étais trompé complètement^^


    Bonjour!

    Alors, je développe un petit jeu en C++ et il s'avère que j'ai un problème avec mes libérations de mémoire^^

    En effet, lorsque j'y arrive, mes "delete" ne semblent pas fonctionner. Je fonctionne avec un menu et une scène 3D. En appuyant sur escape, on libère la mémoire allouée et on retourne au menu. Or, si je retourne dans la scène grâce à un bouton du menu, la mémoire allouée s'ajoute à la précédente et c'est comme cela jusqu'au plantage du programme si je continue à faire menu/scène 3D indéfiniment.

    En fait, je comprends pas pourquoi mes delete ne font rien... Le gestionnaire des tâches Windows m'affiche une montée d'utilisation de la mémoire en flèche.

    Mais trêve de bavardage, voilà mon code^^ (Certains le reconnaîtront peut-être =))

    obj.h



    /* vector */
    typedef float vec3_t[3];
    typedef float vec4_t[4];


    /* vertex */
    typedef struct
    {
      vec4_t xyzw;

    } obj_vertex_t;


    /* texture coordinates */
    typedef struct
    {
      vec3_t uvw;

    } obj_texCoord_t;


    /* normal vector */
    typedef struct
    {
      vec3_t ijk;

    } obj_normal_t;


    /* polygon */
    typedef struct
    {
      GLenum type;        /* primitive type */
      int num_elems;      /* number of vertices */

      int *vert_indices;  /* vertex indices */
      int *uvw_indices;   /* texture coordinate indices */
      int *norm_indices;  /* normal vector indices */
      int textureID;

    } obj_face_t;

    typedef struct //Pour stocker une texture ou un material
    {
        int textureID;
        GLuint texture;
    } obj_texture_t;

    /* obj model structure */
    typedef struct
    {
      int num_verts;              /* number of vertices */
      int num_texCoords;          /* number of texture coords. */
      int num_normals;            /* number of normal vectors */
      int num_faces;
      int num_texture;             //number of polygons
      GLuint texture;              //Temporaire.

      int has_texCoords;          /* has texture coordinates? */
      int has_normals;            /* has normal vectors? */

        obj_texture_t *textures;
      obj_vertex_t *vertices;     /* vertex list */
      obj_texCoord_t *texCoords;  /* tex. coord. list */
      obj_normal_t *normals;      /* normal vector list */
      obj_face_t *faces;          /* model's polygons */

    } obj_model_t;

    //Les prototypes

    void FreeModel (obj_model_t *mdl);
    int MallocModel (obj_model_t *mdl);
    int FirstPass (FILE *fp, obj_model_t *mdl);
    int SecondPass (FILE *fp, obj_model_t *mdl);
    int ReadOBJModel (const char *filename, obj_model_t *mdl);
    void RenderOBJModel (obj_model_t *mdl);
    void init (const char *filename, int id);
    void shutdownApp (int nb_models);
    void reshape (int w, int h);
    void display (int id);
    void numberModels(int number);



    obj.cpp (seulement les "new" et les "delete")



    void
    shutdownApp (int nb_models) //Pour désallouer la mémoire
    {
        int i;
      /* free memory */

        if(objfile)
        {
            for(i = 0;i <= nb_models; i++) //pour chaque objet.
            {
                if(objfile)
                FreeModel (&objfile[i]); //On donne l'adresse de chaque structure
            }
            delete objfile; //On supprimer finalement le tableau de structure
        }
    }


    int
    MallocModel (obj_model_t *mdl) //On alloue la mémoire
    {
      if (mdl->num_verts) //S'il y a des vertex
        {
          mdl->vertices = new obj_vertex_t[mdl->num_verts];
          if (!mdl->vertices)
            return 0;
        }

      if (mdl->num_texCoords)
        {
          mdl->texCoords = new obj_texCoord_t[mdl->num_texCoords];

          if (!mdl->texCoords)
            return 0;
        }

      if (mdl->num_normals)
        {
          mdl->normals = new obj_normal_t[mdl->num_normals];
          if (!mdl->normals)
            return 0;
        }

      if (mdl->num_faces) //S'il y a des faces
        {
          mdl->faces = new obj_face_t[mdl->num_faces];
          if (!mdl->faces)
            return 0;
        }

        if(mdl->num_texture) //S'il y a des matériaux
        {
            mdl->textures = new obj_texture_t[mdl->num_texture];
            if(!mdl->textures)
            return 0;
        }

      return 1;
    }


    void
    FreeModel (obj_model_t *mdl) //On libère la mémoire
    {
      int i = 0;

      if (mdl)
        {
          if (mdl->vertices) //On désalloue les tableaux de vertices
            {
              delete[] mdl->vertices;
              mdl->vertices = NULL;
            }

          if (mdl->texCoords)
            {
              delete[] mdl->texCoords;
              mdl->texCoords = NULL;
            }

          if (mdl->normals)
            {
              delete[] mdl->normals;
              mdl->normals = NULL;
            }

          if (mdl->faces) //On désalloue les tableaux de faces
            {
              for (i = 0; i < mdl->num_faces ; ++i)
                {
                  if (mdl->faces[i].vert_indices)
                  {
                    delete[] mdl->faces[i].vert_indices;
                    mdl->faces[i].vert_indices = NULL;
                  }

                  if (mdl->faces[i].uvw_indices)
                  {
                    delete[] mdl->faces[i].uvw_indices;
                    mdl->faces[i].uvw_indices = NULL;
                  }

                  if (mdl->faces[i].norm_indices)
                  {
                    delete[] mdl->faces[i].norm_indices;
                    mdl->faces[i].norm_indices = NULL;
                  }
                }

              delete[] mdl->faces;
              mdl->faces = NULL;
            }

            if(mdl->textures) //On désalloue les tableaux de textures
            {
               delete[] mdl->textures;
               mdl->textures = NULL;
            }

        }
    }


    Bien sûr, j'appelle la fonction ShutdownApp comme suit, sachant que j'ai 4 objets en tout:



       shutdownApp(3); //On désalloue le tout.



    S'il manque du code, dîtes-le moi^^

    Enfin, merci à l'avance!
    • Partager sur Facebook
    • Partager sur Twitter

    [Allocation dynamique]

    × 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