Probleme avec un realloc

Signaler
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008
-
manta7
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008
-
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 :(

18 réponses

Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

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.

=
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

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)...
Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

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

=
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

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
Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

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.

=
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

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;
 }
Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

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
=




 
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

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 ;)
Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

RE

Je me demande si tu n'es pas en train de faire un realloc sur du NULL ?
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

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 ?
Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

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

=
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

Mais je comprends pas je m'en sert partout de cette expression comment est ce qu'elle pourrait etre null
Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

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.

=
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

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...
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

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...
Messages postés
317
Date d'inscription
vendredi 25 mai 2007
Statut
Membre
Dernière intervention
19 octobre 2007

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é.

=
Messages postés
402
Date d'inscription
mardi 1 mai 2001
Statut
Membre
Dernière intervention
15 août 2011

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 ::.)~
Messages postés
105
Date d'inscription
samedi 25 janvier 2003
Statut
Membre
Dernière intervention
13 décembre 2008

c'est toujours sympa de participer mais ton cours sur le realloc il me sert à rien