Sujet Précédent Sujet Suivant

Probleme avec un realloc

manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008 - 25 mai 2007 à 16:38
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008 - 27 mai 2007 à 16:41
Salut à tous !
Je suis en train de coder un petit projet mais j'ai un probleme de mémoire avec la fonction realloc()
C'est assez prise de tete car c'est dans des strucutes mais bon voici mon probleme :

J'ai mes 3 structures :

typedef struct _unite {
     int    
        xright, yright, //Chance d'aller a droite
        xleft, yleft, //gauche
        xup, yup, //haut
        xdown, ydown, //bas
        xvue, yvue, //Chance de regarder aux alentours pour prendre
        vietotale, viebase, vie;
 }unite;
 
 typedef struct _classe {
     unite *unite;
     int n; //Nombre d'unités par classe
 }classe;
 
 struct _map {
     int affichage; //Affichage sur affiche()
     int dejavu; //Permet de savoir si une unité a déja effectuée un tour
     unite *unite;
     int element; //Numero d'element dans unite[]
 }map[SMAP][SMAP];

Pour l'allocation tout se passe parfaitement maintenant quand je teste un

classe[map[x][y].affichage].unite=realloc(classe[map[x][y].affichage].unite, sizeof(unite)*(classe[map[x][y].affichage].n));

Pour info j'avais alloué un utilisant la variable n dans la structure classe et avant le realloc, j'incrémente celle ci. C'est une sorte d'indice de taille.

Il me met
*** glibc detected *** ./test: realloc(): invalid pointer: 0x0804c020 ***
===== Backtrace: =========
/lib/tls/i686/cmov/libc.so.6(realloc+0x392)[0xb7ed9322]
/lib/tls/i686/cmov/libc.so.6[0xb7ed9461]
/lib/tls/i686/cmov/libc.so.6(realloc+0x3c)[0xb7ed8fcc]
./test[0x8049eff]
./test[0x804a225]
./test[0x804a69b]
./test[0x804a8e6]
./test[0x804a975]
/lib/tls/i686/cmov/libc.so.6(__libc_start_main+0xdc)[0xb7e83ebc]
./test[0x80484b1]
===== Memory map: ========
08048000-0804b000 r-xp 00000000 08:01 7700495    /home/manta/programmation/c/projet/evolution/test
0804b000-0804c000 rw-p 00003000 08:01 7700495    /home/manta/programmation/c/projet/evolution/test
0804c000-0806d000 rw-p 0804c000 00:00 0          [heap]
b7e6d000-b7e6e000 rw-p b7e6d000 00:00 0
b7e6e000-b7fa9000 r-xp 00000000 08:01 9535640    /lib/tls/i686/cmov/libc-2.5.so
b7fa9000-b7faa000 r--p 0013b000 08:01 9535640    /lib/tls/i686/cmov/libc-2.5.so
b7faa000-b7fac000 rw-p 0013c000 08:01 9535640    /lib/tls/i686/cmov/libc-2.5.so
b7fac000-b7faf000 rw-p b7fac000 00:00 0
b7fb3000-b7fbe000 r-xp 00000000 08:01 9535502    /lib/libgcc_s.so.1
b7fbe000-b7fbf000 rw-p 0000a000 08:01 9535502    /lib/libgcc_s.so.1
b7fbf000-b7fc3000 rw-p b7fbf000 00:00 0
b7fc3000-b7fdc000 r-xp 00000000 08:01 9535503    /lib/ld-2.5.so
b7fdc000-b7fde000 rw-p 00019000 08:01 9535503    /lib/ld-2.5.so
bfe43000-bfe58000 rw-p bfe43000 00:00 0          [stack]
ffffe000-fffff000 r-xp 00000000 00:00 0          [vdso]

Abandon (core dumped)

(je compile avec gcc)

Voila j'espere que vous avez une réponse :(
A voir également:

18 réponses

Réponse 1 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
25 mai 2007 à 17:06
Salut,

Deja, je ne comprend pas ton "classe[map[x][y].affichage].unite"
classe n'est pas un tableau ou un pointeur pour le moment et je vois pas pourquoi tu utiliserais ".affichage" comme indice de "classe"
et donne aussi des informations sur les valeurs que tu prends pour "n" et "SMAP" et sur la maniere dont tu fais l'allocation.

=
0
Réponse 2 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
25 mai 2007 à 17:12
SMAP c'est la taille de la map, je l'utilise pour la structure map
n c'est l'indice pour la structure unite, c'est a dire qu'apres je l'utilise avec un classe[indice].unite[classe.n] pour connaitre ou se situe unite

En fait pour chaque classe il existe plusieurs unités, et mon realloc veut reallouer classe[indice].unite

En ce qui concerne affichage je m'en sert comme indice de classe et y'a jamais eu aucun souci.

Avant que je veuille reallouer classe[map[x][y].affichage].unite, celle ci fonctionne parfaitement d'ou ma "stupeur" quand je fais un simple realloc et meme quand je met une memoire au hasard (plus grande que celle requise)...
0
Réponse 3 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
25 mai 2007 à 17:22
RE

tu reponds pas a ma question en fait : n ? SMAP ? ou est declaree "classe" ? et passe aussi le code ou tu fais ton malloc

=
0
Réponse 4 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
25 mai 2007 à 17:53
classe c'est une structure globale
les allocations :
    classe=malloc(sizeof(classe)*NCLASSE);
    for(i=0;i<NCLASSE;i++)
     {
         classe[i].unite=malloc(sizeof(unite)*UNITE_PER_MAP);
         etc..
     }
n=4
SMAP=10
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
25 mai 2007 à 18:35
Ca serait bien de voir ton code, et pas que le .h
car la segfault se trouve dans le .c

Ainsi on ne peut pas te repondre vraiment, tu vois.

=
0
Réponse 6 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
25 mai 2007 à 18:38
Pourquoi pas :) mais j'ai pas encore fait de .h j'attendais de terminer les fonctions d'initialisations ce que j'ai fait aujourd'hui.

C'est dans la fonction enfant() que le realloc pose probleme

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define SMAP 10 //Taille de la map
#define UNITE_PER_MAP 5 //Nombre d'unité par map
#define NTOUR 50 //Nombre de tour
#define DISTANCE_VUE 2 //Distance de la vision de U4 au départ
#define NFRUITS 5 //Nombre de fruits au départ de la map
#define NFRUITS_PER_TOUR 1 //Nombre de nouveaux fruits par tour
#define FRUITS_FOR_LIFE 5 //Nombre d'années de vie en plus pour un fruit

#define OUI 1
#define NON 0

#define VIDE -1
#define FRUITS -2
#define U0 0 //Préférence pour la droite
#define U1 1 //gauche
#define U2 2 //haut
#define U3 3 //bas
#define U4 4 //Regarde aux alentours

 typedef struct _unite {
     int    
        xright, yright, //Chance d'aller a droite
        xleft, yleft, //gauche
        xup, yup, //haut
        xdown, ydown, //bas
        xvue, yvue, //Chance de regarder aux alentours pour prendre
        vietotale, viebase, vie;
 }unite;
 
 typedef struct _classe {
     unite *unite;
     int n; //Nombre d'unités par classe
 }classe;
 
 struct _map {
     int affichage; //Affichage sur affiche()
     int dejavu; //Permet de savoir si une unité a déja effectuée un tour
     unite *unite;
     int element; //Numero d'element dans unite[]
 }map[SMAP][SMAP];
 
 int NCLASSE=5; //Nombre des différentes espèces sur la map
 
 /*----------------------------------------------------------------------------------------------------
Initialisation à chaque tour de la variable dejavu
----------------------------------------------------------------------------------------------------*/
 
 void inittour(void)
 {
     int i, j;
     for(i=0;i<SMAP;i++)
     {
         for(j=0;j<SMAP;j++)
             map[i][j].dejavu=NON;
     }
    return;
 }
 
/*----------------------------------------------------------------------------------------------------
Initialisation des classes
----------------------------------------------------------------------------------------------------*/
 
classe* initclasse(void)
 {
     int i, j;
     
     classe* classe;
     classe=malloc(sizeof(classe)*NCLASSE);
     
     for(i=0;i<NCLASSE;i++)
     {
         classe[i].unite=malloc(sizeof(unite)*UNITE_PER_MAP);
         for(j=0;j=0)
                 return NON;
         }
     }
     return OUI;
 }
 
/*----------------------------------------------------------------------------------------------------
 Affiche la map
----------------------------------------------------------------------------------------------------*/
 
  void affiche()
 {
     int i, j;
     
     for(i=0;i<SMAP;i++)
     {
         for(j=0;j<SMAP;j++)
         {
             if(map[i][j].affichage>=0 && map[i][j].affichage<=9)
                //printf(" %d ", map[i][j].affichage);
                printf(" %d ",map[i][j].unite[map[i][j].element].vie);
             else
                 printf("%d ",map[i][j].affichage);
         }
         printf("\n");
     }
     return;
 }

/*----------------------------------------------------------------------------------------------------
Valeur absolue
----------------------------------------------------------------------------------------------------*/
 
 int abs(int x)
 {
     if(x<0)
         return -x;
     else
         return x;
 }
 
/*----------------------------------------------------------------------------------------------------
Calcule la distance entre 2 points
----------------------------------------------------------------------------------------------------*/
 
 int distance(int i, int j, int x, int y)
 {
     return abs(i-x)+abs(j-y);
 }
 
/*----------------------------------------------------------------------------------------------------
L'action est de type vision
----------------------------------------------------------------------------------------------------*/
 
 void vision(classe * classe, int x, int y)
 {
     int i, j;
     
     for(i=0;i<SMAP;i++)
     {
         for(j=0;j<SMAP;j++)
         {
             if(distance(i, j, x, y)<=DISTANCE_VUE)
             {
                 if(map[i][j].affichage==FRUITS)
                 {
                     map[x][y].unite[map[x][y].element].vie+=(FRUITS_FOR_LIFE+1);//On ajoute 1 pour ne pas perdre d'année de vie en mangeant un fruit
                     map[i][j].affichage=VIDE;
                     return;
                 }
             }
         }
     }
     return;
 }

/*----------------------------------------------------------------------------------------------------
Teste s'il y a une place vide a coté de la mere ou du pere
----------------------------------------------------------------------------------------------------*/
 
 int* placevide(int x, int y, int sx, int sy)
 {
     int *vide;
     
     vide=malloc(sizeof(int)*3);
     
     if(y!=SMAP-1 && map[x][y+1].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=x;
         vide[2]=y+1;
     }
     else if(y!=0 && map[x][y-1].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=x;
         vide[2]=y-1;
     }
     else if(x!=SMAP-1 && map[x+1][y].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=x+1;
         vide[2]=y;
     }
     else if(x!=0 && map[x-1][y].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=x-1;
         vide[2]=y;
     }
     else if(sy!=SMAP-1 && map[sx][sy+1].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=sx;
         vide[2]=sy+1;
     }
     else if(sy!=0 && map[sx][sy-1].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=sx;
         vide[2]=sy+1;
     }
     else if(sx!=SMAP-1 && map[sx+1][sy].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=sx;
         vide[2]=sy+1;
     }
     else if(sx!=0 && map[sx-1][sy].affichage==VIDE)
     {
         vide[0]=1;
         vide[1]=sx;
         vide[2]=sy+1;
     }
     else
         vide[0]=0;
         
     return vide;
 }     
 
/*----------------------------------------------------------------------------------------------------
Evolution
----------------------------------------------------------------------------------------------------*/
 
 void evolution(classe * classe, int x, int y, int sx, int sy)
 {
     int cdroit, cgauche, chaut, cbas, cvue, cvie;
     int *vide;
     
     vide=placevide(x,y,sx,sy);
     if(vide[0])
     {
         cdroit=(map[x][y].unite[map[x][y].element].yright-map[x][y].unite[map[x][y].element].xright+map[sx][sy].unite[map[sx][sy].element].yright-map[sx][sy].unite[map[sx][sy].element].xright)/2;
         cgauche=(map[x][y].unite[map[x][y].element].yleft-map[x][y].unite[map[x][y].element].xleft+map[sx][sy].unite[map[sx][sy].element].yleft-map[sx][sy].unite[map[sx][sy].element].xleft)/2;
         chaut=(map[x][y].unite[map[x][y].element].yup-map[x][y].unite[map[x][y].element].xup+map[sx][sy].unite[map[sx][sy].element].yup-map[sx][sy].unite[map[sx][sy].element].xup)/2;
         cbas=(map[x][y].unite[map[x][y].element].ydown-map[x][y].unite[map[x][y].element].xdown+map[sx][sy].unite[map[sx][sy].element].ydown-map[sx][sy].unite[map[sx][sy].element].xdown)/2;
         cvue=(map[x][y].unite[map[x][y].element].yvue-map[x][y].unite[map[x][y].element].xvue+map[sx][sy].unite[map[sx][sy].element].yvue-map[sx][sy].unite[map[sx][sy].element].xvue)/2;
         
         cvie=(map[x][y].unite[map[x][y].element].viebase-map[sx][sy].unite[map[sx][sy].element].viebase)/2;
         
         classe=realloc(classe, sizeof(classe)*++NCLASSE);
         
         classe[NCLASSE-1].unite=malloc(sizeof(unite)*1);
         classe[NCLASSE-1].n=1;
         
         classe[NCLASSE-1].unite[0].xright=0;
         classe[NCLASSE-1].unite[0].yright=cdroit;
         
         classe[NCLASSE-1].unite[0].xleft=cdroit;
         classe[NCLASSE-1].unite[0].yleft=cdroit+cgauche;
         
         classe[NCLASSE-1].unite[0].xup=cdroit+cgauche;
         classe[NCLASSE-1].unite[0].yup=cdroit+cgauche+chaut;
         
         classe[NCLASSE-1].unite[0].xdown=cdroit+cgauche+chaut;
         classe[NCLASSE-1].unite[0].ydown=cdroit+cgauche+chaut+cbas;
         
         classe[NCLASSE-1].unite[0].xvue=cdroit+cgauche+chaut+cbas;
         classe[NCLASSE-1].unite[0].yvue=100;
         
         classe[NCLASSE-1].unite[0].vie=cvie;
         classe[NCLASSE-1].unite[0].viebase=cvie;
         classe[NCLASSE-1].unite[0].vietotale=0;
         
         map[vide[1]][vide[2]].affichage=NCLASSE-1;
         map[vide[1]][vide[2]].dejavu=OUI;
         map[vide[1]][vide[2]].unite=classe[NCLASSE-1].unite;
         map[vide[1]][vide[2]].element=0;
     }
     
     return;
 }

/*----------------------------------------------------------------------------------------------------
Enfant
----------------------------------------------------------------------------------------------------*/
 
 void enfant(classe * classe, int x, int y, int sx, int sy)
 {
     int *vide;
     vide=placevide(x,y,sx,sy);printf("enfant %d %d %d %d, %d %d %d, %d %d\n%d %d\n",x,y,sx,sy, vide[0], vide[1], vide[2],classe[map[x][y].affichage].n,map[x][y].affichage,sizeof(unite),sizeof(unite)*(classe[map[x][y].affichage].n));
     if(vide[0])
     {
         classe[map[x][y].affichage].n++;
         
         classe[map[x][y].affichage].unite=realloc(classe[map[x][y].affichage].unite, sizeof(unite)*(classe[map[x][y].affichage].n));
         //classe[map[x][y].affichage].unite=realloc( NULL, 300 );
         
         /*map[vide[1]][vide[2]].affichage=map[x][y].affichage;
         map[vide[1]][vide[2]].dejavu=OUI;
         map[vide[1]][vide[2]].unite=classe[map[x][y].affichage].unite;
         map[vide[1]][vide[2]].element=classe[map[x][y].affichage].n-1;
         
         /*map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].vie=classe[map[x][y].affichage].unite[map[x][y].affichage].vie;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].viebase=classe[map[x][y].affichage].unite[map[x][y].affichage].viebase;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].vietotale=classe[map[x][y].affichage].unite[map[x][y].affichage].vietotale;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].xright=classe[map[x][y].affichage].unite[map[x][y].affichage].xright;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].yright=classe[map[x][y].affichage].unite[map[x][y].affichage].yright;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].xleft=classe[map[x][y].affichage].unite[map[x][y].affichage].xleft;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].yleft=classe[map[x][y].affichage].unite[map[x][y].affichage].yleft;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].xup=classe[map[x][y].affichage].unite[map[x][y].affichage].xup;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].yup=classe[map[x][y].affichage].unite[map[x][y].affichage].yup;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].xdown=classe[map[x][y].affichage].unite[map[x][y].affichage].xdown;
         map[vide[1]][vide[2]].unite[ map[vide[1]][vide[2]].element ].xup=classe[map[x][y].affichage].unite[map[x][y].affichage].xup;*/
     }
     //classe[i].unite=malloc(sizeof(unite)*UNITE_PER_MAP);
     return;
 }     
 
/*----------------------------------------------------------------------------------------------------
Deplacement avec test des cas possibles
----------------------------------------------------------------------------------------------------*/
 
 void deplace(classe * classe, int x, int y, int sx, int sy)
 {
     if(map[sx][sy].affichage==VIDE) //Simple déplacement
     {
         map[sx][sy].affichage=map[x][y].affichage;
         map[x][y].affichage=VIDE;
         
         map[sx][sy].unite=map[x][y].unite;
         map[x][y].unite=NULL;
         
         map[sx][sy].element=map[x][y].element;
         map[x][y].element=0;
     }
     else if(map[sx][sy].affichage==FRUITS) //Manger
     {
         map[sx][sy].affichage=map[x][y].affichage;
         map[x][y].affichage=VIDE;
         
         map[sx][sy].unite=map[x][y].unite;
         map[x][y].unite=NULL;
         
         map[sx][sy].element=map[x][y].element;
         map[x][y].element=0;
         
         map[sx][sy].unite[map[sx][sy].element].vie+=(FRUITS_FOR_LIFE+1);
     }
     else //Evolution ou enfant
     {
         if(map[x][y].affichage != map[sx][sy].affichage) //Evolution
            ;//evolution(classe, x, y, sx, sy);
         else //Enfant
             enfant(classe, x, y, sx, sy);
     }
     
     printf("%d %d %d %d %d %d\n",x,y,sx,sy,map[sx][sy].affichage, map[sx][sy].unite[map[sx][sy].element].vie);
     
     return;
 }

/*----------------------------------------------------------------------------------------------------
Action a effectuer d'une unité
----------------------------------------------------------------------------------------------------*/
 
 void action(classe * classe, int i, int j)
 {
     int hasard, cas=1;
     int x, y;
     hasard = rand() % 101;
     
     if(hasard>=map[i][j].unite[map[i][j].element].xleft && hasard <=map[i][j].unite[map[i][j].element].yleft)
     {
         x=i;
         y=j-1;
     }
         
     else if(hasard>=map[i][j].unite[map[i][j].element].xright && hasard <=map[i][j].unite[map[i][j].element].yright)
     {
         x=i;
         y=j+1;
     }
     else if(hasard>=map[i][j].unite[map[i][j].element].xup && hasard <=map[i][j].unite[map[i][j].element].yup)
     {
         x=i-1;
         y=j;
     }
     else if(hasard>=map[i][j].unite[map[i][j].element].xdown && hasard <=map[i][j].unite[map[i][j].element].ydown)
     {
         x=i+1;
         y=j;
     }
     else if(hasard>=map[i][j].unite[map[i][j].element].xvue && hasard <=map[i][j].unite[map[i][j].element].yvue)
        cas=0;
     else
         return;
     //Parfois tout ces cas ne sont pas pris en compte, pourquoi ?
     
     if(cas==0)
        vision(classe,i,j);
     else
     {
         if(x==-1)
            x=SMAP-1;
         if(y==-1)
             y=SMAP-1;
         if(x==SMAP)
             x=0;
         if(y==SMAP)
             y=0;
         
         if(map[x][y].dejavu==NON && x>=0 && x<SMAP && y>=0 && y<SMAP)
         {
             deplace(classe, i, j, x, y);
             map[x][y].dejavu=OUI;
         }
     }
     
     return;
 }
 
/*----------------------------------------------------------------------------------------------------
Fonction appelée a chaque tour
----------------------------------------------------------------------------------------------------*/
 
 void tour(classe * classe)
 {
     int i, j;
     int x,y;
     
     inittour();
     
     x = rand() % 101;
     for(i=0;i<NFRUITS_PER_TOUR;i++)
     {
         x = rand() % SMAP;
         y = rand() % SMAP;
                       
         if(map[x][y].affichage==VIDE) //On crée un nouveau fruit sur (x,y)
             map[x][y].affichage=FRUITS;
         else
             i--;
     }
     
     for(i=0;i<SMAP;i++)
     {
         for(j=0;j<SMAP;j++)
         {
             if(map[i][j].dejavu==NON && map[i][j].affichage>=0)
             {
                if(map[i][j].unite[map[i][j].element].vie<=0)
                    map[i][j].affichage=VIDE;
                 else
                 {
                     map[i][j].unite[map[i][j].element].vie--;
                     action(classe, i, j);
                     map[i][j].dejavu=OUI;
                 }
             }
         }
     }
 }
 
 
/*----------------------------------------------------------------------------------------------------
Ce bon vieux main()
----------------------------------------------------------------------------------------------------*/
 
 int main()
 {
     int i;
     classe * classe;
     srand(time(0));
     
     //Initialisation
     classe=initclasse();
     initmap(classe);
     
     affiche();
     getchar();
     
     while(!apocalypse())
     {
         tour(classe);
         affiche();
         getchar();
     }
     
     printf("APOCALYPSE\n\n");

     return 0;
 }
0
Réponse 7 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
25 mai 2007 à 22:59
Deja j'aime assez comment tu codes. Sauf ta fonction initclasse
avec du code recopie 15 fois et pas de .h pas bien :)

quelle est la difference entre element et unite ? dans classe car a priori, unite c'est juste classe[element].unite

Le reste que je dirais c'est que le bug de ton realloc vient d'une segfault
mais en parcourant le code j'ai pas vu ou tu devrais analyser que tu n'as pas de debordements en commentant les fonctions et en revoyant tout notamment
je relirais ton code demain, à tête plus refaite :)

puis genre classe=realloc(classe, sizeof(classe)*++NCLASSE);
faut pas s'etonner... au pire si tu veux tu pourrais faire aussi des printf pour voir la valeur actuelle de unité et tout ca
bref
=




 
0
Réponse 8 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
26 mai 2007 à 00:50
Merci c'est sympa, mais c'est vrai que la fonction initclasse est affreuse.
J'ai pensé a améliorer la structure unité en enlevant toutes les variables xright, yright, xvue bla bla bla en seulement un tableau d'entier avec des constantes prédéfinies du genre qualite[DROIT]=100 comme ça dans initclasse j'utilise un for et ça simplifierai tout. J'aurai juste a tout reprendre dans mon programme :)

Par contre classe[element].unite comme tu l'as écrit ne fonctionnerai pas car element c'est l'indice de unite c'est plutot classe[affichage].unite[element].

Et pour mon probleme j'ai testé avec des printfs a priori j'ai tout qui fonctionne et qui fait ce dont j'ai envie avant le realloc donc je comprends pas d'ou ça peut venir...

Et puis au fait merci pour ton aide et promis je fais un header ;)
0
Réponse 9 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
26 mai 2007 à 10:12
RE

Je me demande si tu n'es pas en train de faire un realloc sur du NULL ?
0
Réponse 10 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
26 mai 2007 à 12:58
t'es ok que c'est bien cette ligne qui merde :

 classe[map[x][y].affichage].unite=realloc(classe[map[x][y].affichage].unite, sizeof(unite)*(classe[map[x][y].affichage].n));

tu penses que je realloc sur du NULL ?
0
Réponse 11 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
26 mai 2007 à 13:21
RE

Que ca soit cette ligne qui merde, c'est pas obligatoire. Si c'est une segfault, ca peut venir de n'importe ou ailleurs et seulement se remarquer a cet endroit la,  mais oui, je te proposerais de verifier que le premier argument est pas NULL avant de faire ton realloc

=
0
Réponse 12 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
26 mai 2007 à 13:47
Mais je comprends pas je m'en sert partout de cette expression comment est ce qu'elle pourrait etre null
0
Réponse 13 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
26 mai 2007 à 13:54
Re

ben teste ?

Parce que tu t'en sers partout mais les parametres changent a chaque fois
 et pour trouver des erreurs faut parfois tester et d'autres fois faut afficher les resultats.

=
0
Réponse 14 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
26 mai 2007 à 14:13
Je comprends pas je teste plusieurs parametres, je fais des printf, et meme un printf de l'adresse de ce que je veux reallouer, y'a tout qui marche, je comprends pas...
0
Réponse 15 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
26 mai 2007 à 14:20
Ca me rend fou j'ai passé je sais pas combien de temps sur ce probleme de mémoire et y'a rien qui n'a avancé depuis...
0
Réponse 16 / 18
The_Guardian Messages postés 317 Date d'inscription vendredi 25 mai 2007 Statut Membre Dernière intervention 19 octobre 2007 1
26 mai 2007 à 15:08
RE

Bon, faut debugger, tu as un probleme qui va etre dur à trouver car ton code est assez gros et pas facile a lire.
Donc pour decouvrir ou ca plante, il faut que tu commentes tout ce qui est inutile jusqu'a n'avoir plus rien, puis tu remets au fur et a mesure les fonctions dont dependent ta fonction enfant
En mettant des printf("pointeur=%x\n", classe[...].unite); tu fais ca pour l'indice qui plante ca tu le connais avec des printf aussi et tu remontes l'erreur
Un programme vide ne plante pas!
Donc ton but est de trouver le plut petit programme qui va planter, et ca devrait aller une fois que tu as fait ca car l'erreur va etre evidente.

Je vois pas comment t'aider plus autrement, désolé.

=
0
Réponse 17 / 18
NitRic Messages postés 402 Date d'inscription mardi 1 mai 2001 Statut Membre Dernière intervention 15 août 2011
26 mai 2007 à 20:15
un realloc() avec un pointeur NULL et une taille de zéro ou non est l'équivalent d'un malloc() ...
un realloc() avec un pointeur non NULL et une taille de zéro est l'équivalent à un free() ...
ce n'est pas conseillé mais on peut tout faire avec realloc()

~(.:: NitRic ::.)~
0
Réponse 18 / 18
manta7 Messages postés 105 Date d'inscription samedi 25 janvier 2003 Statut Membre Dernière intervention 13 décembre 2008
27 mai 2007 à 16:41
c'est toujours sympa de participer mais ton cours sur le realloc il me sert à rien
0

Discussions similaires

taille Fichier avec malloc et realloc
cs_halima -
halima -

9 réponses
SOS!!! realloc explications....
pastaga29 -
emmatopiak -

7 réponses
équivalent REALLOC en C++ !!!
ElectricalMan -
steve_clamage -

8 réponses
Probleme avec realloc() ...
cs_Tidam -
steve_clamage -

4 réponses
Realloc en java
FiReTiTi -
Twinuts -

2 réponses
Rejoignez-nous