Conflit d'adresse entre deux tableaux

Version imprimable

Bonjour,

Lors de l'exécution de mon programme, les valeurs d'un de mes tableaux sont modifiées involontairement au moment où les valeurs d'un autre tableau sont modifiées.

Lorsque j'affiche les adresses des éléments de ces deux tableaux, je m'aperçois que plusieurs d'entre elles sont identiques. D'où le conflit.

Le premier tableau est défini dans mon main.c ainsi:

Code:

REEL *caraelemress;

Le second tableau appartient à la structure suivante déclarée dans un .h
Code:

1 2 3 4 5 6 7 typedef struct elements_ { INT * numelt; INT * pconnect; /* liste des pointeurs sur la connectivite des elements dans 'connectivite' }ELEMENTS;
Si j'affiche les adresses de ces deux tableaux avec les lignes suivantes:

NB: "p1" est un pointeur qui a pris pour valeur "elements.pconnect"
"nb_elt" est la dimension de pconnect
Code:

1 2 3 for (i=0;i<nb_elt+1;i++){ printf("p1[%d] = %d \t à l'adresse %d \n",i,p1[i],&p1[i]); }
et,

Code:

for(i=0;i<14;i++)printf("&caraelemress[%d] = %f\t à l'adresse %d \n",i,caraelemress[i],&(caraelemress[i]));

je récupère dans mon terminal respectivement:
Code:

1 2 3 4 5 6 7 8 p1[0] = 1 à l'adresse 235837680 p1[1] = 9 à l'adresse 235837684 p1[2] = 17 à l'adresse 235837688 p1[3] = 19 à l'adresse 235837692 p1[4] = 21 à l'adresse 235837696 p1[5] = 23 à l'adresse 235837700 p1[6] = 25 à l'adresse 235837704
et,
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 &caraelemress[0] = 210000.000000 à l'adresse 235837632 &caraelemress[1] = 0.000000 à l'adresse 235837640 &caraelemress[2] = 0.000000 à l'adresse 235837648 &caraelemress[3] = 0.000000 à l'adresse 235837656 &caraelemress[4] = 0.000000 à l'adresse 235837664 &caraelemress[5] = 0.000000 à l'adresse 235837672 &caraelemress[6] = 0.000000 à l'adresse 235837680 &caraelemress[7] = 0.000000 à l'adresse 235837688 &caraelemress[8] = 0.000000 à l'adresse 235837696 &caraelemress[9] = 0.000000 à l'adresse 235837704 &caraelemress[10] = 0.000000 à l'adresse 235837712 &caraelemress[11] = 0.000000 à l'adresse 235837720 &caraelemress[12] = 0.000000 à l'adresse 235837728 &caraelemress[13] = 0.000000 à l'adresse 235837736
Entre autres, p1[2] et caraelemress[7] ont la même adresse.

Avez-vous une idée d'où cette erreur peut venir ?

Merci d'avance

Anthony

13/04/2011, 12h24
diogene

Dans ce que tu montres, il n'y a pas de tableaux : caraelemress et le champ pconnect ne sont pas des tableaux mais des pointeurs.

Il serait plus simple de montrer le code incriminé, notamment celui de la création de ces tableaux.

Voici les lignes de code qui créent l'espace mémoire pour la structure "elements"

Code:

1
2
3
4
5
6
7
8
/* allocation de l'espace
     des elements
     ---------------------- */
  if ( Alloc_elements(&elements) )
  {
          dammsg(ERR_PILE_,routine);
          return(-1);
  }

La fonction Alloc_elements appelée est la suivante: (Dans mon message précédent, j'avais retiré plusieurs champs dans la déclaration de la structure.)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
INT Alloc_elements(struct elements_ * var){
  register INT code_erreur = 0 ;
 
  if( ((var->numelt=integer_alloc(var->numelt,nb_elt))==(INT*)(NULL)) ||
  ((var->propnumtyp=integer_alloc(var->propnumtyp,nb_elt))==(INT*)(NULL)) ||
  ((var->formelts=integer_alloc(var->formelts,nb_elvol))==(INT*)(NULL)) ||
  ((var->repelt=integer_alloc(var->repelt,2*nb_elvol))==(INT*)(NULL)) ||
  ((var->pconnect=integer_alloc(var->pconnect,nb_elt+1))==(INT*)(NULL)) ||
  ((var->numstr=integer_alloc(var->numstr,nb_elvol))==(INT*)(NULL)) ||
  ((var->codelt=integer_alloc(var->codelt,nb_elt))==(INT*)(NULL)) ||
  ((var->repcorota0=Real_alloc(var->repcorota0 ,9*nb_elpou))==(REEL*)(NULL)) ||
  ((var->coordlocini=Real_alloc(var->coordlocini,nb_elpou))==(REEL*)(NULL)) ||
  ((var->connectneuels=integer_alloc(var->connectneuels,mx_connec))==(INT*)(NULL)) )
  {
      dammsg(ERR_ALLOCMEM_,"struct elements_","Alloc_elements");
      code_erreur=1;
  }
 
  return code_erreur;
}

La fonction Real_alloc est:

Code:

1
2
3
4
5
6
7
8
 
REEL * Real_alloc(REEL * var, const INT nElements) {
  register INT i;
  if (nElements < 0) return((REEL *)(NULL));
  if ((var=NEW_DIM(var,nElements,REEL))==(REEL *)NULL) return((REEL *)(NULL));
  for (i = 0; i<nElements; i++) var[i] = c__zero;
  return var;
}

et Integer_alloc:

Code:

1
2
3
4
5
INT * integer_alloc(INT * var, const INT nElements) {
  INT i;
  if (nElements < 0) {
    return (INT *)(NULL);
  }

Et l'espace mémoire pour caraelemress est alloué ici:

Code:

1
2
3
4
5
6
 
  if ((caraelemress=(REEL *)Real_alloc((REEL *)NULL,indref))==((REEL *)NULL))
  {
     dammsg(ERR_ALLOCMEM_,"caraelemress",routine);
     return(-1);
  }

Ca fait beaucoup de code d'un coup ! Merci pour ton aide.

Pour info supplémentaire, c'est entre les lignes 20 et 36 de la fonction suivante (lorsque je manipule les valeurs du tableau pointé par caraelemress), que les valeurs du tableau pointé par pconnect de ma structure elements sont involontairement modifiées.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
void caraelemressort(REEL *cararess, REEL *caraelemress)
{printf("------------ ENTRE DANS CARAELEMRESSORT ---------\n");
 
 /*variables locales*/
   register INT i;
   register REEL v,E,G,A,J,Iy,Iz;
   REEL *p;
 
 
 
	  printf("adresses des éléments de la matrice de rigidité \n");
 
 
	for(i=0;i<14;i++)printf("&caraelemress[%d] = %f\t à l'adresse %d \n",i,caraelemress[i],&(caraelemress[i]));
 
 
 
   /* terme E.A */
   caraelemress[2]=E*A;
 
   /* terme G.J */
   caraelemress[3]=G*J;
 
   affiche_table_elem();
   /* terme 2*E.Iy */
   v=c__deux*E*Iy;
   caraelemress[4]=v;
   v*=c__deux;
   caraelemress[6]=v;
 
   /* terme 2*E.Iz */
   v=c__deux*E*Iz;
   caraelemress[5]=v;
   v*=c__deux;
   caraelemress[7]=v;
   affiche_table_elem();
 
    p=&caraelemress[2];
   for(i=6;i<14;i++) p[i]=cararess[i]; 
	for(i=0;i<14;i++)printf("caraelemress[%d] = %f \n",i,caraelemress[i]);
	for(i=0;i<14;i++)printf("cararess[%d] = %f \n",i,cararess[i]);
printf("------------ SORTIE DE CARAELEMRESSORT ---------\n");
}

13/04/2011, 16h34
diogene

Le code qui dit créer de l'espace mémoire pour les elements : if ( Alloc_elements(&elements) ) : ne crée pas de structure elements_. celle-ci doit déjà pré-exister et même ses champs doivent avoir été initialisés par quelque chose puisqu'ils sont en arguments des integer_alloc() et Real_alloc() dans Alloc_elements().

Si on regarde Real_alloc() (je suppose que integer_alloc() fonctionne pareillement, mais son code est incomplet), on peut penser que NEW_DIM() est une macro (à cause de l'argument REEL) qui alloue ou plutôt réalloue dynamiquement (puisque var est en argument, sinon à quoi servirait-il ?), mais alors on est surpris par la remise à zéro de la ligne 6 qui suit.

Bref, il manque des informations à préciser, car là c'est un peu un jeu de devinettes. Au minimum :
- la macro NEW_DIM()
- le code de création et initialisation de la structure struct elements_ en argument de Alloc_elements()

Sinon, beaucoup de cast inutiles (inutile de caster NULL) qui alourdissent le code. La présence de cast montre souvent une mauvaise maîtrise du code.

Voici la fonction integer_alloc complète (désolé pour cet oubli):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
INT * integer_alloc(INT * var, const INT nElements) {
  INT i;
  if (nElements < 0) {
    return (INT *)(NULL);
  }
 
  var = (INT *)( (var!=(INT *)(NULL)) ? 
        realloc((void *)var, nElements*SIZINT_) :
        calloc(nElements, SIZINT_));
 
  if (var != (INT *)(NULL)) {
	printf("\t initialisation \n");
    for (i = 0; i<nElements; i++) {
	var[i] = 0;   /* initialisation a 0 */
	}
  }
  return (INT *)var;
}

Concernant le rôle de var, voici ce commentaire:

Code:

1
2
3
4
5
6
7
 
/* 
   FONCTIONS GENERALES D'ALLOCATION : 
      parametres - var       : pointeur sur le tableau a allouer
                 - nElements : nombre d'elements
      retournent un pointeur (=NULL en cas d'echec) sur la variable a allouer
*/

NEW_DIM est en effet une macro:

Code:

1
2
3
4
 
#define NEW_DIM(var, n, type) ( (var) = (type *)((var) ? \
                        realloc((char *)(var), (unsigned)(n)*sizeof(type)) : \
                        calloc((unsigned)(n), sizeof(type))))

En ce qui concerne la création de la structure elements, je ne vois pas d'autre code que:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
typedef struct elements_ {
  INT    *  numelt;            /* tableau de numerotation des elements
                                  (dim = nb_elt) */
  INT    *  propnumtyp;        /* liste des
                                  numeros de prop num des elements volumiques 
                                  numeros de prop pou des elements poutres
				  numero de prop ress des elements ressorts
                                  type des ddl esclaves des elements rigide
                                  fid contenant la definition des super-elements
                                  (dim = nb_elt) */
  INT    *  formelts;          /* codes des formes geometriques des elements 
                                 volumiques 
                                  (dim = nb_elvol) */
  INT    *  repelt;            /* liste des numeros (utilisateur/internes) 
                                  de reperes et de calcul de contrainte
                                  des elements volumique
                                  (dim = 2*nb_elvol) */
  INT    *  numstr;            /* liste des numeros (utilisateur/internes) de 
                                  stratification des elements volumiques
                                  (dim = nb_elvol) */
  INT    *  codelt;            /* liste des codes interne des elements
                                  (dim = nb_elt) */
 
  INT    *  pconnect;          /* liste des pointeurs sur la connectivite des 
                                  elements dans 'connectivite' 
                                  (dim = nb_elt+1)*/
  INT    *  connectneuels;     /* liste (utilisateur/internes) des 
                                  connectivites des elements
                                  (dim = mx_connec) */
  REEL   *  repcorota0;        /* tableau des matrices de rotation initial du
                                  repere corotationel de l'element 
                                  (dim= 9 * nb_elpou ) */ 
  REEL   *  coordlocini;       /* tableau des coordonees variables initials de
                                  l'element dans sont repere corotationel
                                   (dim= nb_elpou ) */ 
}ELEMENTS;

Je crois que cette partie de code doit permettre de passer chacun des champs de cette structure dans des fonctions telles que Integer_alloc ou Real_alloc.

Je suis conscient que je ne fais que lancer des morceaux de code et des commentaires de code dont je ne saisi pas à 100% les rôles. Je continue de parcourir ton dernier post pour apporter des précisions sur mon problème. En espérant que celles puisse t'aider à le résoudre. Merci pour cette aide.

14/04/2011, 10h41
Anthony_CTI
Bonjour,

Il me semble que j'ai trouvé mon erreur.

Le tableau pointé par "elements.pconnect" est alloué le premier. Plus tard vient l'allocation du tableau pointé par "caraelemress". De plus, le code concernant "caraelemress" est bien plus récent dans l'historique de création de ce programme. Pour rappel, "caraelemress" était alloué ainsi:
Code:

1 2 3 4 5 6 if ((caraelemress=(REEL *)Real_alloc((REEL *)NULL,indref))==((REEL *)NULL)) { dammsg(ERR_ALLOCMEM_,"caraelemress",routine); return(-1); }
La fonction Real_alloc prend pour argument le pointeur sur tableau à allouer et le nombre d'éléments de ce tableau. Telles que rédigée ci-dessus, il me semble que le premier argument renseigné à l'appel de Real_alloc est le pointeur NULL. ce n'est donc pas l'adresse attendue (première erreur). D'autre part, après affichage, le deuxième argument, indref, vaut 2. Or, la dimension du tableau pointé par caraelemress est supérieure. En effet, 14 éléments sont appelés par la suite. Ce tableau déborde donc sur son voisin, elements.pconnect (deuxième erreur).
Je propose donc le code suivant:
Code:

1 2 3 4 5 6 if ((caraelemress=(REEL *)Real_alloc(caraelemress,20))==((REEL *)NULL)) { dammsg(ERR_ALLOCMEM_,"caraelemress",routine); return(-1); }
mon premier argument "caraelemress" est le pointeur sur le tableau que je veux allouer. Mon deuxième argument est "14", dimension du tableau.

A priori, je n'ai plus de conflit d'adresse. La question: Correction ou bidouillage supplémentaire ?

Citation:

NEW_DIM est en effet une macro:

Donc, effectivement, NEW_DIM() fait une première allocation si le pointeur est NULL ou sinon une réallocation.
Elle n'est normalement pas utilisable en toute sécurité pour des réels ou des pointeurs car le calloc() ne garantit pas dans ce cas la mise à 0.0 des réels ou à NULL des pointeurs et il faudrait explicitement les mettre ensuite à 0.0 ou à NULL.
On peut se demander par contre pourquoi integer_alloc() ne l'utilise pas.
De plus, en cas d'échec de la réallocation, une fuite mémoire se produit. Le schéma devrait être (sous la forme d'une fonction)
Code:

1 2 3 4 5 6 7 8 9 10 #define NEW_DIM(var, n, type) New_Alloc((var),(n)*sizeof(type)) void * New_Alloc(void* var, size_t n) { void * p = realloc(var,n); if(p==NULL) free(var); // libérer la mémoire précédemment allouée return p; } .... int *p = NULL; p = NEW_DIM(p,5,int);
Citation:

En ce qui concerne la création de la structure elements, je ne vois pas d'autre code que:

Ce code définit un type ELEMENTS, pas une variable de ce type. Il faudrait avoir quelque chose comme :
Code:

1 2 3 4 ELEMENTS elements; //ou des variantes struct elements_ elements; ELEMENTS *elements = malloc(...) ....
Citation:

il me semble que le premier argument renseigné à l'appel de Real_alloc est le pointeur NULL. ce n'est donc pas l'adresse attendue (première erreur).

Ce n'est pas une erreur, c'est une demande de première allocation (voir commentaires plus haut sur NEW_DIM())

Citation:

D'autre part, après affichage, le deuxième argument, indref, vaut 2. Or, la dimension du tableau pointé par caraelemress est supérieure. En effet, 14 éléments sont appelés par la suite. Ce tableau déborde donc sur son voisin, elements.pconnect (deuxième erreur).

Là, c'est grave. Evidemment, on peut agrandir artificiellement le tableau, comme tu le suggères plus bas, mais la question à résoudre impérativement est plutôt "pourquoi cette valeur indref n'est-elle pas la bonne ?" car cela cache potentiellement un bug ailleurs dans le programme.

14/04/2011, 14h31
Anthony_CTI

Citation:

Ce n'est pas une erreur, c'est une demande de première allocation (voir commentaires plus haut sur NEW_DIM())

Il est vrai que si je change juste artificiellement la dimension du tableau alloué sans modifier le premier argument de Real_alloc, il n'y a plus de conflit d'adresse. Je dois donc déterminer si la valeur de "indref" est fausse ou si l'appel d'éléments "hors tableau" par la suite est incohérent. Ceci est un autre chapitre...

Mon problème de conflit d'adresse est donc résolu. Je te remercie de m'avoir orienté dans la recherche de ce bug et de souligner, au passage, d'autre source d'erreur.