Allocation d'un tableau dynamique dans une structure

Version imprimable

Bonjour

Voici ma structure :

Code:

1
2
3
4
5
6
7
8
9
10
struct part {
  double  x, y, z ;
  double  vx, vy, vz ;
  double  frcx, frcy, frcz ;
  double  dx, dy, dz ;
  int	  nbrevoisin ;
  double  Eint, Tint ;
  int	  *listevoisin ;
} ;
typedef struct part Particules ;

J'ai une fonction où je fais les allocations de mes structures :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
int allocation( int Natom, Data *Donnees, Particules *Particule[]  ) {
 
....
 
// structure particule
  *Particule = calloc( Natom, sizeof(Particules) ) ;
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p = Particule[iat] ;
    p->listevoisin = calloc( Donnees->nbrevoisinmax, sizeof(int) ) ;
  }
 
....
 
}

Le problème c'est que j'ai un segmentation fault. J'ai exécuté avec gdb et ça me donne ça :

Code:

1
2
3
Program received signal SIGSEGV, Segmentation fault.
allocation (Natom=1000, Donnees=0xbfffed6c, Particule=0xbfffed68) at allocation.c:24
24            p->listevoisin = calloc( Donnees->nbrevoisinmax, sizeof(int) ) ;

J'ai essayé avec malloc au lieu de calloc. Et j'ai essayé aussi avec ça comme déclaration mais ça ne change rien.

Code:

1
2
3
4
5
  *Particule = calloc( Natom,  sizeof(Particules) + Donnees->nbrevoisinmax * sizeof(int)  ) ;
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p = Particule[iat] ;
    p->listevoisin = malloc( Donnees->nbrevoisinmax, sizeof(int) ) ;
  }

Merci pour votre aide

08/02/2010, 19h03
kamouminator

peut tu montrer comment tu appel allocation ?
un code qui compile serait le bienvenu !

Voici un code qui reproduit l'erreur. J'ai essayé de virer le maximum de choses. Le code complet commence à peser un peu plus de 1000 lignes !

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
/* * * * * librairies */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
 
/* * * * * structure particule */
struct part {
  double  x, y, z ;
  double  vx, vy, vz ;
  double  frcx, frcy, frcz ;
  double  dx, dy, dz ;
  int	  nbrevoisin ;
  double  Eint, Tint ;
  int	  *listevoisin ;
} ;
typedef struct part Particules ;
 
 
/* * * * * structure etat thermodynamique */
struct etat {
  int     nat ;
  double  volume, temperature, pression ;
// ...
} ;
typedef struct etat Etat ;
 
 
/* * * * * structure contenant les donnees */
struct data {
  /* variables de la namelist */
  int     nstep ;		// nbre iteration
  double  dt ;			// pas de temps
  double  xsi ;			// friction
  double  temp0 ;		// temperature cible
  double  rcut ;		// cut off
  double  rverlet ;		// cut off liste voisin
  int     nbrevoisinmax ;	// nbre maximum de voisins
  // ...
} ;
typedef struct data Data ;
 
/* prototypes */
int init_calcul( Data * , Etat *, Particules ** ) ;
int allocation( int , Data *, Particules **  ) ;
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
  *                                                                           * 
  * programme princpal                                                        * 
  *                                                                           * 
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int main( void ) {
 
  int erreur = EXIT_SUCCESS ;
 
/* Declaration des structures */
  Etat        EtatThermo ;	// alias = e
  Data        Donnees ;		// alias = d
  Particules  *Particule ;	// alias = p
 
/* gestion de la ligne de commande */
 
/* ouverture des fichiers */
 
/* message d'accueil */
 
/* Lecture de l'input et initialisation des variables : */
  init_calcul( &Donnees, &EtatThermo, &Particule ) ;
 
/* fermeture des fichiers */
 
  return erreur;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *                                                                           * 
 * initialisation du calcul                                                  * 
 *                                                                           * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int init_calcul ( Data *Donnees, Etat *EtatThermo, Particules *Particule[] ) {
 
  int     erreur = EXIT_SUCCESS ;
 
/* enregistrement des valeurs par defaut */
 
/* lecture de l'input */
 
// ....
 
  EtatThermo->nat = 1000 ;
  Donnees->nbrevoisinmax = 100 ;
 
/* allocation des tableaux nat = nombre d'atome */
  fprintf ( stdout, " * allocation de la memoire\n") ;
  allocation( EtatThermo->nat, Donnees, &(*Particule) ) ;
 
// ...
 
  return erreur ;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *                                                                           * 
 * allocation des tableaux dynamique : forces, positions, vitesses           * 
 *                                                                           * 
 * initialistion a 0 de tous les tableaux                                    * 
 *                                                                           * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int allocation( int Natom, Data *Donnees, Particules *Particule[]  ) {
 
  Particules *p = NULL ;
  int erreur = EXIT_SUCCESS ;
  int iat, ivois ;
 
// structure particule
  *Particule = malloc( Natom * ( sizeof(Particules) + Donnees->nbrevoisinmax * sizeof(int) ) ) ;
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p = Particule[iat] ;
    p->listevoisin = malloc( Donnees->nbrevoisinmax * sizeof(int) ) ;
  }
 
// ...
 
 
// initialisation a 0 de tous les tableaux
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p = Particule[iat] ;
 
    p->x = 0. ;
    p->y = 0. ;
    p->z = 0. ;
 
    p->vx = 0. ;
    p->vy = 0. ;
    p->vz = 0. ;
 
    p->frcx = 0. ;
    p->frcy = 0. ;
    p->frcz = 0. ;
 
    p->dx = 0. ;
    p->dy = 0. ;
    p->dz = 0. ;
 
    p->nbrevoisin = 0 ;
 
    for( ivois = 0 ; ivois < Donnees->nbrevoisinmax ; ivois++ )
    	p->listevoisin[ivois] = 0 ;
  }
 
  return erreur ;
}

08/02/2010, 21h07
Pouet_forever

Tu alloues un peu n'importe quoi :

Code:

*Particule = malloc( Natom * ( sizeof(Particules) + Donnees->nbrevoisinmax * sizeof(int) ) ) ;

tu passe en argument:

Code:

Particules *Particule[]

qui est un tableau de pointeur de Particules.

il est donc necessaire d'allouer dans un premier temps le tableau de pointeurs:

Code:

Particule = malloc( Natom * ( sizeof(Particules*))) ;

puis d'allouer chaque particule une a une:

Code:

1
2
3
for ( iat = 0 ; iat < Natom ; iat++ ) {
    Particule[iat] = malloc( sizeof(Particules)) ;
}

ce qui donne:

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
45
46
47
48
int allocation( int Natom, Data *Donnees, Particules *Particule[]  ) {
 
    Particules *p = NULL ;
    int erreur = EXIT_SUCCESS ;
    int iat, ivois ;
 
    // structure particule
 
    Particule = malloc( Natom * ( sizeof(Particules*))) ;
    for ( iat = 0 ; iat < Natom ; iat++ ) {
        Particule[iat] = malloc( sizeof(Particules)) ;
    }
    for ( iat = 0 ; iat < Natom ; iat++ ) {
        p = Particule[iat] ;
        p->listevoisin = malloc( Donnees->nbrevoisinmax * sizeof(int) ) ;
    }
 
    // ...
 
 
    // initialisation a 0 de tous les tableaux
    for ( iat = 0 ; iat < Natom ; iat++ ) {
        p = Particule[iat] ;
 
        p->x = 0. ;
        p->y = 0. ;
        p->z = 0. ;
 
        p->vx = 0. ;
        p->vy = 0. ;
        p->vz = 0. ;
 
        p->frcx = 0. ;
        p->frcy = 0. ;
        p->frcz = 0. ;
 
        p->dx = 0. ;
        p->dy = 0. ;
        p->dz = 0. ;
 
        p->nbrevoisin = 0 ;
 
        for( ivois = 0 ; ivois < Donnees->nbrevoisinmax ; ivois++ )
            p->listevoisin[ivois] = 0 ;
    }
 
    return erreur ;
}

j'ai testé, ça marche !

j'avais pas vu le main... la façon de declarer les particules dans le main me fais croire que tu souhaite utiliser un tableau de particules et non un tableau de pointeur de particules...

dans ce cas ça change la chose:

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
/* * * * * librairies */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
 
/* * * * * structure particule */
struct part {
    double  x, y, z ;
    double  vx, vy, vz ;
    double  frcx, frcy, frcz ;
    double  dx, dy, dz ;
    int  nbrevoisin ;
    double  Eint, Tint ;
    int  *listevoisin ;
} ;
typedef struct part Particules ;
 
 
/* * * * * structure etat thermodynamique */
struct etat {
    int     nat ;
    double  volume, temperature, pression ;
    // ...
} ;
typedef struct etat Etat ;
 
 
/* * * * * structure contenant les donnees */
struct data {
    /* variables de la namelist */
    int     nstep ;       // nbre iteration
    double  dt ;            // pas de temps
    double  xsi ;         // friction
    double  temp0 ;     // temperature cible
    double  rcut ;        // cut off
    double  rverlet ;       // cut off liste voisin
    int     nbrevoisinmax ;   // nbre maximum de voisins
    // ...
} ;
typedef struct data Data ;
 
/* prototypes */
int init_calcul( Data * , Etat *, Particules ** ) ;
int allocation( int , Data *, Particules **  ) ;
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
**   *                                                                           * 
**     * programme princpal                                                        * 
**       *                                                                           * 
**         * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int main( void ) {
 
    int erreur = EXIT_SUCCESS ;
 
    /* Declaration des structures */
    Etat        EtatThermo ;    // alias = e
    Data        Donnees ;     // alias = d
    Particules  *Particule ;    // alias = p
 
    /* gestion de la ligne de commande */
 
    /* ouverture des fichiers */
 
    /* message d'accueil */
 
    /* Lecture de l'input et initialisation des variables : */
    init_calcul( &Donnees, &EtatThermo, &Particule ) ;
 
    /* fermeture des fichiers */
 
    return erreur;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
**  *                                                                           * 
**   * initialisation du calcul                                                  * 
**    *                                                                           * 
**     * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int init_calcul ( Data *Donnees, Etat *EtatThermo, Particules **Particule ) {
 
    int     erreur = EXIT_SUCCESS ;
 
    /* enregistrement des valeurs par defaut */
 
    /* lecture de l'input */
 
    // ....
 
    EtatThermo->nat = 1000 ;
    Donnees->nbrevoisinmax = 100 ;
 
    /* allocation des tableaux nat = nombre d'atome */
    fprintf ( stdout, " * allocation de la memoire\n") ;
    allocation( EtatThermo->nat, Donnees, Particule ) ;
 
    // ...
 
    return erreur ;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
**  *                                                                           * 
**   * allocation des tableaux dynamique : forces, positions, vitesses           * 
**    *                                                                           * 
**     * initialistion a 0 de tous les tableaux                                    * 
**      *                                                                           * 
**       * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int allocation( int Natom, Data *Donnees, Particules **Particule  ) {
 
    Particules *p = NULL ;
    int erreur = EXIT_SUCCESS ;
    int iat, ivois ;
 
    // structure particule
 
    *Particule = malloc( Natom * ( sizeof(Particules))) ;
    for ( iat = 0 ; iat < Natom ; iat++ ) {
        p = &((*Particule)[iat]) ;
        p->listevoisin = malloc( Donnees->nbrevoisinmax * sizeof(int) ) ;
    }
 
    // ...
 
 
    // initialisation a 0 de tous les tableaux
    for ( iat = 0 ; iat < Natom ; iat++ ) {
        p = &((*Particule)[iat]) ;
 
        p->x = 0. ;
        p->y = 0. ;
        p->z = 0. ;
 
        p->vx = 0. ;
        p->vy = 0. ;
        p->vz = 0. ;
 
        p->frcx = 0. ;
        p->frcy = 0. ;
        p->frcz = 0. ;
 
        p->dx = 0. ;
        p->dy = 0. ;
        p->dz = 0. ;
 
        p->nbrevoisin = 0 ;
 
        for( ivois = 0 ; ivois < Donnees->nbrevoisinmax ; ivois++ )
            p->listevoisin[ivois] = 0 ;
    }
 
    return erreur ;
}

08/02/2010, 22h18
Ladgalen

Merci pour ton aide

Citation:

Envoyé par kamouminator

j'avais pas vu le main... la façon de declarer les particules dans le main me fais croire que tu souhaite utiliser un tableau de particules et non un tableau de pointeur de particules...

Exact, dans ta phrase "qui est un tableau de pointeur de Particules" quelque chose me gênait mais je n'arrivais pas à voir exactement le problème.

dans ce cas ça change la chose:

Citation:

Envoyé par kamouminator

Code:

p = &((*Particule)[iat]) ;

là par contre je ne comprend pas ce que ça représente. J'ai essayé de tester rapidement, ça n'a pas marché. J'ai encore segmentation fault si j'essaye d'imprimer les valeurs de x y z. Je testerai plus fort demain. Merci encore.
08/02/2010, 22h37
kamouminator

Particule correspond à un pointeur ver ton tableau.
*Particule correspond a ton tableau
(*Particule)[iat] correspond à un element du tableau
et comme p est un pointeur de particule il te faut l'adresse de la particule en question soit:

Code:

&((*Particule)[iat])

Bonjour

Beh malheureusement je confirme que j'ai toujours une segmentation fault. Elle n'est pas à la même ligne qu'avant (on progresse). Cette fois j'ai cette erreur :

Code:

1
2
3
4
5
 
Program received signal SIGSEGV, Segmentation fault.
0x00000000004006a9 in allocation (Natom=1000, Donnees=0x7fff2b41f4f0, Particule=0x7fff2b41f4e8)
    at main.c:153
126             p->listevoisin[ivois] = 0 ;

Je remet le code exact que j'ai utilisé :

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/* * * * * librairies */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
 
/* * * * * structure particule */
struct part {
  double  x, y, z ;
  double  vx, vy, vz ;
  double  frcx, frcy, frcz ;
  double  dx, dy, dz ;
  int	  nbrevoisin ;
  double  Eint, Tint ;
  int	  *listevoisin ;
} ;
typedef struct part Particules ;
 
/* * * * * structure etat thermodynamique */
struct etat {
  int     nat ;
} ;
typedef struct etat Etat ;
 
/* * * * * structure contenant les donnees */
struct data {
  int     nbrevoisinmax ;	// nbre maximum de voisins
} ;
typedef struct data Data ;
 
/* * * * * prototypes */
int init_calcul( Data * , Etat *, Particules ** ) ;
int allocation( int , Data *, Particules **  ) ;
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *                                                                           * 
 * programme princpal                                                        * 
 *                                                                           * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int main( void ) {
 
  int erreur = EXIT_SUCCESS ;
 
  Etat        EtatThermo ;
  Data        Donnees ;	
  Particules  *Particule = NULL ;
 
  init_calcul( &Donnees, &EtatThermo, &Particule ) ;
 
  return erreur;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *                                                                           * 
 * initialisation du calcul                                                  * 
 *                                                                           * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int init_calcul ( Data *Donnees, Etat *EtatThermo, Particules *Particule[] ) {
 
  Particules *p ;
  int erreur = EXIT_SUCCESS ;
  int i ;
 
  EtatThermo->nat = 1000 ;
  Donnees->nbrevoisinmax = 100 ;
 
/* allocation des tableaux nat = nombre d'atome */
  fprintf ( stdout, " * allocation de la memoire\n") ;
  allocation( EtatThermo->nat, Donnees, Particule ) ;
 
  for ( i = 0 ; i < EtatThermo->nat ; i++ ) {
    p = &((*Particule)[i]) ;
    printf("%5d %e \n", i, p->x ) ;
  }
 
  return erreur ;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *                                                                           * 
 * allocation des tableaux dynamique : forces, positions, vitesses           * 
 *                                                                           * 
 * initialistion a 0 de tous les tableaux                                    * 
 *                                                                           * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int allocation( int Natom, Data *Donnees, Particules *Particule[]  ) {
 
  Particules *p = NULL ;
  int erreur = EXIT_SUCCESS ;
  int iat, ivois ;
 
// structure particule
  *Particule = malloc( Natom * sizeof(Particules *) ) ;
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p = &((*Particule)[iat]) ;
    p->listevoisin = calloc( Donnees->nbrevoisinmax, sizeof(int) ) ;
  }
 
// initialisation a 0 de tous les tableaux
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p =  &((*Particule)[iat]) ;
 
    p->x = 0. ;
    p->y = 0. ;
    p->z = 0. ;
 
    p->vx = 0. ;
    p->vy = 0. ;
    p->vz = 0. ;
 
    p->frcx = 0. ;
    p->frcy = 0. ;
    p->frcz = 0. ;
 
    p->dx = 0. ;
    p->dy = 0. ;
    p->dz = 0. ;
 
    p->nbrevoisin = 0 ;
 
    for( ivois = 0 ; ivois < Donnees->nbrevoisinmax ; ivois++ )
    	p->listevoisin[ivois] = 0 ;
  }
 
  return erreur ;
}

09/02/2010, 09h52
kamouminator

dans allocation, jefais:

Code:

*Particule = malloc( Natom * ( sizeof(Particules))) ;

et tu fais:

Code:

*Particule = malloc( Natom * sizeof(Particules *) ) ;

(Particules*) a une taille de 4octets
alors que Particules est bien plus grand

Yes

J'ai trouvé l'erreur (ou en tout cas une façon de faire marcher les choses).

Pour l'allocation j'ai fait comme ça :

Code:

1
2
3
4
5
  *Particule = calloc( Natom, sizeof(Particules *) + Donnees->nbrevoisinmax * sizeof(int) ) ;
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p = &((*Particule)[iat]) ;
    p->listevoisin = calloc( Donnees->nbrevoisinmax, sizeof(int) ) ;
  }

J'alloue le tableau de structure en disant que chaque élément de la structure doit avoir une taille correspondant à structure plus la taille du tableau que contiendra la structure. Comme dans la structure listevoisin est déclaré comme un pointeur sur un entier, dans sizeof(Particules) il ne tient compte que de la taille d'un entier ce qui ne va pas. Du coup le code suivant marche.

EDIT : Tu as posté entre temps, la petite étoile de différence fais que ça marche aussi :mouarf: et ça me semble plus propre ! J'ai modifier le programme en fonction de ça.

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/* * * * * librairies */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
 
/* * * * * structure particule */
struct part {
  double  x, y, z ;
  double  vx, vy, vz ;
  double  frcx, frcy, frcz ;
  double  dx, dy, dz ;
  int	  nbrevoisin ;
  double  Eint, Tint ;
  int	  *listevoisin ;
} ;
typedef struct part Particules ;
 
/* * * * * structure etat thermodynamique */
struct etat {
  int     nat ;
} ;
typedef struct etat Etat ;
 
/* * * * * structure contenant les donnees */
struct data {
  int     nbrevoisinmax ;	// nbre maximum de voisins
} ;
typedef struct data Data ;
 
/* * * * * prototypes */
int init_calcul( Data * , Etat *, Particules ** ) ;
int allocation( int , Data *, Particules **  ) ;
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
  *                                                                           * 
  * programme princpal                                                        * 
  *                                                                           * 
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int main( void ) {
 
  int erreur = EXIT_SUCCESS ;
 
  Etat        EtatThermo ;
  Data        Donnees ;	
  Particules  *Particule = NULL ;
 
  init_calcul( &Donnees, &EtatThermo, &Particule ) ;
 
  return erreur;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *                                                                           * 
 * initialisation du calcul                                                  * 
 *                                                                           * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int init_calcul ( Data *Donnees, Etat *EtatThermo, Particules *Particule[] ) {
 
  Particules *p ;
  int erreur = EXIT_SUCCESS ;
  int i ;
 
  EtatThermo->nat = 1000 ;
  Donnees->nbrevoisinmax = 100 ;
 
/* allocation des tableaux nat = nombre d'atome */
  fprintf ( stdout, " * allocation de la memoire\n") ;
  allocation( EtatThermo->nat, Donnees, Particule ) ;
 
  for ( i = 0 ; i < EtatThermo->nat ; i++ ) {
    p = &((*Particule)[i]) ;
    printf("%5d %e \n", i, p->x ) ;
  }
 
  return erreur ;
}
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
 *                                                                           * 
 * allocation des tableaux dynamique : forces, positions, vitesses           * 
 *                                                                           * 
 * initialistion a 0 de tous les tableaux                                    * 
 *                                                                           * 
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
int allocation( int Natom, Data *Donnees, Particules *Particule[]  ) {
 
  Particules *p = NULL ;
  int erreur = EXIT_SUCCESS ;
  int iat, ivois ;
 
// structure particule
  *Particule = calloc( Natom , sizeof(Particules) ) ;
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p = &((*Particule)[iat]) ;
    p->listevoisin = calloc( Donnees->nbrevoisinmax, sizeof(int) ) ;
  }
 
// initialisation a 0 de tous les tableaux
  for ( iat = 0 ; iat < Natom ; iat++ ) {
    p =  &((*Particule)[iat]) ;
 
    p->x = 0. ;
    p->y = 0. ;
    p->z = 0. ;
 
    p->vx = 0. ;
    p->vy = 0. ;
    p->vz = 0. ;
 
    p->frcx = 0. ;
    p->frcy = 0. ;
    p->frcz = 0. ;
 
    p->dx = 0. ;
    p->dy = 0. ;
    p->dz = 0. ;
 
    p->nbrevoisin = 0 ;
 
    for( ivois = 0 ; ivois < Donnees->nbrevoisinmax ; ivois++ )
    	p->listevoisin[ivois] = 0 ;
  }
 
  return erreur ;
}

Par contre j'ai toujours du mal avec mon pointeur de pointeurs **Particule et cette notation : &((*Particule)[iat]) .

Est ce que les définitions suivantes sont justes (en se plaçant dans une fonction, pas dans le main) :

**Particule est un pointeur sur un tableau de Particule.
*p est un pointeur sur une structure particule.
*Particule c'est mon tableau de structure => donc c'est Particule[].
Je n'arrive pas à comprendre ce qu'est *Particule[iat]

Une dernière chose. Si je veux écrire

Code:

1
2
3
4
5
 
Particules *p = NULL ;
 
p = &((*Particule)[iat]) ;
p->x = 0. ;

Sans passer par le pointeur p, comment je fais ? Je n'arrive pas à trouver une écriture qui soit équivalente sans utiliser une varibles supplémentaire.

Merci pour ton aide

Citation:
Envoyé par Ladgalen
J'ai trouvé l'erreur (ou en tout cas une façon de faire marcher les choses).

Pour l'allocation j'ai fait comme ça :
Code:

1 2 3 4 5 *Particule = calloc( Natom, sizeof(Particules *) + Donnees->nbrevoisinmax * sizeof(int) ) ; for ( iat = 0 ; iat < Natom ; iat++ ) { p = &((*Particule)[iat]) ; p->listevoisin = calloc( Donnees->nbrevoisinmax, sizeof(int) ) ; }
il faut arreter ce genre de bidouille, tu ne fais que reporter a plus tard le crachage de ton appli.

sinon Particule est un pointeur vers un tableau soit un pointeur de pointeur.
*Particule correspond donc à l'adresse du premier élément du tableau.
(*Particule)[i] correspond a l'element i de ton tableau.
pour eviter d'utiliser p:

Code:

(*Particule)[i].x