Discussion :

[Anthony_CTI]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

REEL  *caraelemress;

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

	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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[Anthony_CTI]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Anthony_CTI]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[Anthony_CTI]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

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

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[diogene]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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.

[Anthony_CTI]

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.