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 :(

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.

===

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

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

===

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

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.

===

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<UNITE_PER_MAP;j++)
         {
             if(i==U0)
             {
                 classe[i].unite[j].xright=0;
                 classe[i].unite[j].yright=100;
                 classe[i].unite[j].xleft=classe[i].unite[j].xup=classe[i].unite[j].xdown=classe[i].unite[j].yleft=classe[i].unite[j].yup=classe[i].unite[j].ydown=0;
                 
                 classe[i].unite[j].xvue=classe[i].unite[j].yvue=0;
                 
                 classe[i].unite[j].vie=10;
                 classe[i].unite[j].viebase=10;
                 classe[i].unite[j].vietotale=0;
             }
             else if(i==U1)
             {
                 classe[i].unite[j].xleft=0;
                 classe[i].unite[j].yleft=100;
                 classe[i].unite[j].xright=classe[i].unite[j].xup=classe[i].unite[j].xdown=classe[i].unite[j].yright=classe[i].unite[j].yup=classe[i].unite[j].ydown=0;
                 
                 classe[i].unite[j].xvue=classe[i].unite[j].yvue=0;
                 
                 classe[i].unite[j].vie=10;
                 classe[i].unite[j].viebase=10;
                 classe[i].unite[j].vietotale=0;
             }
             else if(i==U2)
             {
                 classe[i].unite[j].xup=0;
                 classe[i].unite[j].yup=100;
                 classe[i].unite[j].xleft=classe[i].unite[j].xright=classe[i].unite[j].xdown=classe[i].unite[j].yleft=classe[i].unite[j].yright=classe[i].unite[j].ydown=0;
                 
                 classe[i].unite[j].xvue=classe[i].unite[j].yvue=0;
                 
                 classe[i].unite[j].vie=10;
                 classe[i].unite[j].viebase=10;
                 classe[i].unite[j].vietotale=0;
             }
             else if(i==U3)
             {
                 classe[i].unite[j].xdown=0;
                 classe[i].unite[j].ydown=100;
                 classe[i].unite[j].xleft=classe[i].unite[j].xup=classe[i].unite[j].xright=classe[i].unite[j].yleft=classe[i].unite[j].yup=classe[i].unite[j].yright=0;
                 
                 classe[i].unite[j].xvue=classe[i].unite[j].yvue=0;
                 
                 classe[i].unite[j].vie=10;
                 classe[i].unite[j].viebase=10;
                 classe[i].unite[j].vietotale=0;
             }
             else if(i==U4)
             {
                 classe[i].unite[j].xleft=classe[i].unite[j].xup=classe[i].unite[j].xright=classe[i].unite[j].yleft=classe[i].unite[j].yup=classe[i].unite[j].yright=0;
                 classe[i].unite[j].xdown=classe[i].unite[j].ydown=0;
                 
                 classe[i].unite[j].xvue=0;
                 classe[i].unite[j].yvue=100;
                 
                 classe[i].unite[j].vie=20;
                 classe[i].unite[j].viebase=20;
                 classe[i].unite[j].vietotale=0;
             }
             classe[i].n=UNITE_PER_MAP;
         }
     }
     return classe;
 }

/*----------------------------------------------------------------------------------------------------
Initialisation de la map de départ
----------------------------------------------------------------------------------------------------*/
 
void initmap(classe * classe)
 {
     int i, j;
     int x,y;
     
     //On initialise chaque case a VIDE
     for(i=0;i<SMAP;i++)
     {
         for(j=0;j<SMAP;j++)
         {
             map[i][j].affichage=VIDE;
             map[i][j].unite=NULL;
             map[i][j].element=0;
         }
     }
   
     //On s'occupe des unités
     for(i=0;i<NCLASSE;i++)
     {
         for(j=0;j<UNITE_PER_MAP;j++)
         {
             x = rand() % SMAP;
             y = rand() % SMAP;
                       
             if(map[x][y].affichage==VIDE) //On crée une nouvelle unité sur (x,y)
             {
                 map[x][y].unite=classe[i].unite;
                 map[x][y].element=j;
                 map[x][y].affichage=i;
             }
             else
                j--;
         }
     }
     
     //On s'occupe des fruits
     for(i=0;i<NFRUITS;i++)
     {
         x = rand() % SMAP;
         y = rand() % SMAP;
         
         if(map[x][y].affichage==VIDE)
             map[x][y].affichage=FRUITS;
         else
             i--;
     }
     //printf("%d %d\n",map[0][0].affichage, map[0][0].unite[0].vie);
     return;
 }
 
/*----------------------------------------------------------------------------------------------------
On regarde s'il y a encore des unités vivantes
----------------------------------------------------------------------------------------------------*/

 int apocalypse(void)
 {
     int i, j;
     for(i=0;i<SMAP;i++)
     {
         for(j=0;j<SMAP;j++)
         {
             if(map[i][j].affichage>=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;
 }

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
===

 

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 ;)

RE

Je me demande si tu n'es pas en train de faire un realloc sur du NULL ?