Structure et realloc

Version imprimable

Bonjour,

Je suis confronté à une difficulté technique que je n'arrive pas à aborder.
J'ai une structure contenant un double pointeur sur un size_t. Il est censé représente un tableau à une dimension. Cependant, ne connaissant pas la taille de ce tableau à l'avance, je suis obligé d'utiliser la fonction realloc d'où l'utilisation d'un double pointeur car l'allocation se fait dans une fonction et non dans le main où la variable a été crée.

Le but du code étant de charger dans un tableau à 3 dimensions le contenu d'un fichier d'extension CSV.

FONCTION

Code:

void T1( t_data *data )

Code:

1
2
3
4
/* On fait pointer ce nouveau tableau sur le tableau contenant la taille de chaque cellule du tableur */
data->(*allocateCell) = testRealloc;
/* On enregistre la taille de la cellule courante*/
data->(*allocateCell)[data->allocateCellSize] = cellLength;

ERREUR COMPILATEUR : error: expected identifier before '(' token pour les deux lignes

FONCTION

Code:

char ***allocateCSV( t_data *data )

Code:

array[i][j] = (char*)malloc((data->(*allocateCell)[counter])*sizeof(char));

ERREUR COMPILATEUR : error: expected identifier before '(' token

Voici le code intégrale :

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
typedef struct
{
    char ***spreadSheet;
    size_t row;
    size_t line;
    size_t **allocateCell;
    size_t allocateCellSize;
    char *CSVpath;
}t_data;
 
t_data *createDataStructure( const char *CSVpath )
{
    t_data *data = (t_data*)malloc(sizeof(t_data));
 
    if ( data != NULL )
    {
        data->spreadSheet = NULL;
        data->row = 0;
        data->line = 0;
        data->allocateCell = NULL;
        data->allocateCellSize = 0;
        strcpy( data->CSVpath, CSVpath );
    }
 
    else exit(-1);
 
    return data;
}
 
void T1( t_data *data )
{
    /* On ouvre un pointeur sur le fichier CSV */
    FILE *CSVfile = fopen(data->CSVpath,"r");
 
    if( CSVfile != NULL )
    {
        /* Variable qui lit le caractère courant parcouru dans le fichier */
        char character;
 
        /* Variable qui compte le nombre de caractère à reserver pour chaque cellule du tableur */
        size_t cellLength = 1;
 
        char *testRealloc = NULL;
 
        /* On parcours le fichier */
        while( fscanf(CSVfile,"%c",&character) != EOF )
        {
            /* Si on passe à une autre cellule */
            if ( character == ';' || character == '\n' )
            {
                if ( character == ';' && data->line == 0 ) { data->row  = data->row  + 1;}
                if ( character == '\n'                   ) { data->line = data->line + 1;}
 
                /* On alloue une case suplémentaire pour le tableau qui contient la taille de chaque cellule du tableur */
                testRealloc = realloc( testRealloc, (data->allocateCellSize+1)*sizeof(size_t));
 
                if ( testRealloc != NULL )
                {
                    /* On fait pointer ce nouveau tableau sur le tableau contenant la taille de chaque cellule du tableur */
                    data->(*allocateCell) = testRealloc;
                    /* On enregistre la taille de la cellule courante*/
                    data->(*allocateCell)[data->allocateCellSize] = cellLength;
                    /* On incrémente la valeur de la taille totale de ce tableau */
                    data->allocateCellSize = data->allocateCellSize + 1;
                }
 
                else exit(-1);
 
                /* On réinitialise à 0 la taille de la cellule pour recommencer avec la suivante */
                cellLength = 0;
            }
 
            /* On incrémente la taille de la cellule */
            cellLength++;
        }
 
        /* On ferme le pointeur sur le fichier CSV */
        fclose(CSVfile);
    }
 
}
 
char ***allocateCSV( t_data *data )
{
    char ***array = (char***)malloc( (data->line)*sizeof(char**) );
 
    size_t i;
    for ( i=0 ; i<data->line ; i++ )
    {
        array[i] = (char**)malloc(data->row*sizeof(char*));
    }
 
    size_t counter=0;
    size_t j;
    for ( i=0 ; i<data->line ; i++)
        for( j=0 ; j<data->row ; j++ )
        {
            array[i][j] = (char*)malloc((data->(*allocateCell)[counter])*sizeof(char));
            counter++;
        }
 
    return array;
}
 
void T2( t_data *data )
{
    /* On ouvre un pointeur sur le fichier CSV */
    FILE *CSVfile = fopen(data->CSVpath,"r");
 
    if( CSVfile != NULL )
    {
        /* Variable qui lit le caractère courant parcouru dans le fichier */
        char character;
 
        /* Variables qui permettent de placer le caractère lu dans le tableau */
        size_t x = 0;
        size_t y = 0;
        size_t i = 0;
 
        /* On parcours le fichier */
        while( fscanf(CSVfile,"%c",&character) != EOF )
        {
            if ( character != ';' || character != '\n' )
            {
                data->spreadSheet[x][y][i] = character;
                i++;
            }
 
            if ( character == '\n')
            {
                x++;
            }
 
            if ( character == ';' )
            {
                data->spreadSheet[x][y][i] = '\0';
                i=0;
            }
        }
 
        /* On ferme le pointeur sur le fichier CSV */
        fclose(CSVfile);
    }
 
}
 
char *** getCSV( char *CSVpath )
{
    t_data *data = createDataStructure( CSVpath );
 
    T1( data );
 
    data->spreadSheet = allocateCSV( data );
 
    T2( data );
 
    return data->spreadSheet;
}

Merci d'avance.

15/04/2011, 18h20
jeroman

Salut

J'ai pas analysé ton code en détail, donc... :lol:

Code:

testRealloc = realloc( testRealloc, (data->allocateCellSize+1)*sizeof(size_t));

Est-ce que tu ne voulais pas plutôt faire

Code:

testRealloc = realloc( data->allocateCell , (data->allocateCellSize+1)*sizeof(size_t));

?
Si tu agrandis le tableau, n'oublie pas de mettre les nouveaux éléments (qui sont des pointeurs) à NULL.

A la place de

Code:

data->(*allocateCell) = testRealloc;

ce serait plutôt

Code:

data->allocateCell = testRealloc;

Code:

exit(...);

Je dirais : à bannir. :ccool: En principe, si une erreur se présente, on la fait remonter, cela permet de bien structurer le déroulement du programme. D'autant qu'en principe, à chaque malloc doit se rapporter un free, car c'est au programme de nettoyer lui-même la mémoire qu'il a allouée (une fois qu'il n'en a plus besoin). Or, un exit termine le programme ; du coup c'est à l'OS de s'en charger. Même s'il s'en charge très bien, au niveau programmation, c'est pas propre.
15/04/2011, 18h47
darkwall_37

Merci, cela règle surement un autre problème qui aurait survenu lors de l'exécution. Cependant, auriez vous une idée pour le problème énoncé ?

Merci.
15/04/2011, 19h07
diogene

Ce qui doit suivre l'opérateur -> ou l'opérateur . doit être l'identificateur du champ d'une structure.

En écrivant

Code:

data->(*allocateCell)

et quelle que soit la définition de allocateCell, l'opérande de -> est une expression, pas l'identificateur d'un champ.

Citation:

Envoyé par jeroman

Salut

Si tu agrandis le tableau, n'oublie pas de mettre les nouveaux éléments (qui sont des pointeurs) à NULL.

Code:

exit(...);

Je dirais : à bannir. :ccool: En principe, si une erreur se présente, on la fait remonter, cela permet de bien structurer le déroulement du programme. D'autant qu'en principe, à chaque malloc doit se rapporter un free, car c'est au programme de nettoyer lui-même la mémoire qu'il a allouée (une fois qu'il n'en a plus besoin). Or, un exit termine le programme ; du coup c'est à l'OS de s'en charger. Même s'il s'en charge très bien, au niveau programmation, c'est pas propre.

Pour votre première, remarque je ne suis pas sûr de bien comprendre ce que vous proposez.

J'ai essayé de réfléchir à partir de vos remarques et à priori, il semble que j'ai pu résoudre grâce à celles-ci ce problème. Concernant la terminaison du programme, j'ai rajouté dans le else ce que je crois être les bonnes lignes de code pour corriger la libération mémoire en cas d'échec du realloc ; est-ce vraiment le cas ?

Merci à vous deux. Je suis repartis sur un code à part pour essayer de comprendre ce qui n'allait pas, voilà j'espère que c'est correct.

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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
    int *ptr;
}myStruct;
 
 
void allocatePtr( int **ptr )
{
    int *testRealloc = NULL;
 
    size_t i;
    for ( i=0 ; i<10 ; i++)
    {
        testRealloc = realloc( testRealloc, (i+1)*sizeof(int));
 
        if ( testRealloc != NULL )
        {
            *ptr = testRealloc;
            (*ptr)[i] = i;
        }
    }
}
 
void allocateStruct( myStruct **structure )
{
    int *testRealloc = NULL;
 
    size_t i;
    for ( i=0 ; i<10 ; i++)
    {
        testRealloc = realloc( testRealloc, (i+1)*sizeof(int));
 
        if ( testRealloc != NULL )
        {
            (*structure)->ptr = testRealloc;
            (*structure)->ptr[i] = i;
        }
 
        else
        {
            free(testRealloc);
            free((*structure)->ptr);
            free(structure);
            exit(-1);
        }
    }
}
 
int main ()
{
    int *ptr;
    myStruct *structure = (myStruct*)malloc( sizeof(myStruct) );
 
    allocatePtr( &ptr );
    allocateStruct( &structure );
 
    size_t i;
    for ( i=0 ; i<10 ; i++)
    {
        printf("\n %d -- %d", ptr[i], structure->ptr[i] );
    }
 
    /* Desallocation des ressources allouées */
    free(ptr);
    free(structure->ptr);
    free(structure);
 
    return 0;
}

EDIT : Je rajoute le code débuggé (en tout cas sur mon exemple, j'ai ce que je veux ) qui permet de charger en mémoire un tableur au format CSV si cela peut servir à quelqu'un.

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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
char *myStrCpy( const char *string )
{
    char *newString = (char *)malloc( (strlen(string)+1)*sizeof(char) );
 
    if ( newString != NULL )
    {
        size_t i;
        for ( i=0 ; i<strlen(string) ; i++ )
        {
            newString[i] = string[i];
        }
 
        newString[i] = '\0';
    }
 
    else
    {
        free(newString);
        exit(-1);
    }
 
    return newString;
}
 
void display3DCharArray( char ***ptr, size_t x, size_t y )
{
    size_t i,j;
    for ( i=0 ; i<x ; i++ )
        for ( j=0 ; j<y ; j++ )
        {
            printf("%s", ptr[i][j]);
        }
}
 
void dealloc3DCharArray( char ***array, size_t x, size_t y )
{
    size_t i,j;
    for ( i=0 ; i<x ; i++ )
        for ( j=0 ; j<y ; j++ )
        {
            free(array[i][j]);
        }
 
    for ( i=0 ; i<x ; i++ )
    {
        free(array[i]);
    }
 
    free(array);
}
 
/* Structure regroupant les données utiles */
typedef struct
{
 
    char ***spreadSheet;        /* Représentation du tableur                                            */
    size_t row;                 /* Nombre de colonnes dans le tableur                                   */
    size_t line;                /* Nombre de lignes dans le tableur                                     */
    size_t *allocateCell;       /* Tableau qui donne la taille à allouer pour chaque cellule du tableur */
    size_t allocateCellSize;    /* La taille du tableau allocateCell                                    */
    char *CSVpath;              /* Le chemin du tableur à traiter                                       */
}t_data;
 
/* Création de la structure de données */
t_data *createDataStructure( const char *CSVpath )
{
    t_data *data = (t_data*)malloc(sizeof(t_data));
 
    if ( data != NULL )
    {
        data->spreadSheet = NULL;
        data->row = 1;
        data->line = 1;
        data->allocateCell = NULL;
        data->allocateCellSize = 0;
        data->CSVpath = myStrCpy( CSVpath );
    }
 
    else
    {
        free(data);
        exit(-1);
    }
 
    return data;
}
/* Destruction de la structure de données */
void destroyDataStructure( t_data *data )
{
    free(data->allocateCell);
    free(data->CSVpath);
    dealloc3DCharArray( data->spreadSheet, data->line, data->row );
    free(data);
}
 
/* Allocation de la structure représentant le tableur */
char ***allocateCSV( t_data *data )
{
    char ***array = (char***)malloc( (data->line)*sizeof(char**) );
 
    size_t i;
    for ( i=0 ; i<data->line ; i++ )
    {
        array[i] = (char**)malloc(data->row*sizeof(char*));
    }
 
    size_t counter=0;
    size_t j;
    for ( i=0 ; i<data->line ; i++)
        for( j=0 ; j<data->row ; j++ )
        {
            array[i][j] = (char*)malloc((data->allocateCell[counter])*sizeof(char));
            counter++;
        }
 
    return array;
}
 
/* Premier traitement : on récupère la taille à allouer pour chaque cellule ainsi que les dimensions du tableur */
void T1( t_data **data )
{
    /* On ouvre un pointeur sur le fichier CSV */
    FILE *CSVfile = fopen((*data)->CSVpath,"r");
 
    if( CSVfile != NULL )
    {
        /* Variable qui lit le caractère courant parcouru dans le fichier */
        char character;
 
        /* Variable qui compte le nombre de caractère à reserver pour chaque cellule du tableur */
        size_t cellLength = 0;
 
        size_t *testRealloc = NULL;
 
        /* On parcours le fichier */
        while( fscanf(CSVfile,"%c",&character) != EOF )
        {
            /* On incrémente la taille de la cellule */
            cellLength++;
 
            /* Si on passe à une autre cellule */
            if ( character == ';' || character == '\n' )
            {
                if ( character == ';' && (*data)->line == 1 ) { (*data)->row  = (*data)->row  + 1;}
                if ( character == '\n'                      ) { (*data)->line = (*data)->line + 1;}
 
                /* On alloue une case suplémentaire pour le tableau qui contient la taille de chaque cellule du tableur */
                testRealloc = realloc( testRealloc, ((*data)->allocateCellSize+1)*sizeof(size_t));
 
                if ( testRealloc != NULL )
                {
                    /* On fait pointer ce nouveau tableau sur le tableau contenant la taille de chaque cellule du tableur */
                    (*data)->allocateCell = testRealloc;
                    /* On enregistre la taille de la cellule courante*/
                    (*data)->allocateCell[(*data)->allocateCellSize] = cellLength;
                    /* On incrémente la valeur de la taille totale de ce tableau */
                    (*data)->allocateCellSize = (*data)->allocateCellSize + 1;
                }
 
                else exit(-1);
 
                /* On réinitialise à 0 la taille de la cellule pour recommencer avec la suivante */
                cellLength = 0;
            }
 
        }
 
        (*data)->line = (*data)->line - 1;
        /* On ferme le pointeur sur le fichier CSV */
        fclose(CSVfile);
    }
 
}
 
/* Remplissage des données contenues dans le tableur vers sa structure de destination */
void T2( t_data *data )
{
    /* On ouvre un pointeur sur le fichier CSV */
    FILE *CSVfile = fopen(data->CSVpath,"r");
 
    if( CSVfile != NULL )
    {
        /* Variable qui lit le caractère courant parcouru dans le fichier */
        char c;
 
        /* Variable qui stocke le caractère précédent */
        char _c = 'a';
 
        /* Variables qui permettent de placer le caractère lu dans le tableau */
        size_t x = 0;
        size_t y = 0;
        size_t z = 0;
 
        /* On parcours le fichier */
        while( fscanf(CSVfile,"%c",&c) != EOF )
        {
 
            if ( _c == ';' && c == ';' )
            {
                data->spreadSheet[x][y][z] = '\0';
                y++;
                z=0;
            }
 
            if ( _c == ';' && c == '\n' )
            {
                data->spreadSheet[x][y][z] = '\0';
                x++;
                y=0;
                z=0;
            }
 
            if ( _c == '\n' && c == ';' )
            {
                data->spreadSheet[x][y][z] = '\0';
                y++;
                z=0;
            }
 
            if ( _c == ';' && ((32 <= c && c <= 58)||(60 <= c && c <= 122)) )
            {
                data->spreadSheet[x][y][z] = c;
                z++;
            }
 
            if ( ((32 <= _c && _c <= 58)||(60 <= _c && _c <= 122)) && c == ';' )
            {
                data->spreadSheet[x][y][z] = '\0';
                y++;
                z=0;
            }
 
            if ( ((32 <= _c && _c <= 58)||(60 <= _c && _c <= 122)) &&  ((32 <= c && c <= 58)||(60 <= c && c <= 122)) )
            {
                data->spreadSheet[x][y][z] = c;
                z++;
            }
 
            if ( _c == '\n' && ((32 <= c && c <= 58)||(60 <= c && c <= 122)) )
            {
                data->spreadSheet[x][y][z] = c;
                z++;
            }
 
            if ( ((32 <= _c && _c <= 58)||(60 <= _c && _c <= 122)) && c == '\n' )
            {
                x++;
                y=0;
                z=0;
            }
 
            _c = c;
        }
 
        /* On ferme le pointeur sur le fichier CSV */
        fclose(CSVfile);
    }
 
}
 
/* Fonction qui renvoie l'ensemble des données à traiter */
t_data *getCSV( char *CSVpath )
{
    /* Création de la structure des données utiles pour le traitement ulterieurs des données */
    t_data *data = createDataStructure( CSVpath );
 
    /* On récupère la dimension du tableur ainsi que la taille de chacune de ses cellules pour préparer sa mise en mémoire */
    T1( &data );
 
    /* On alloue la structure qui va stocker le tableur en mémorie */
    data->spreadSheet = allocateCSV( data );
 
    /* On remplie le tableur */
    T2( data );
 
    /* On renvoie l'ensemble des données collectées */
    return data;
}

Et un exemple de main qui va avec :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <stdlib.h>
#include "getCSV.h"
 
int main (void)
{
    t_data *data = getCSV("alia.csv");
    display3DCharArray( data->spreadSheet, data->line, data->row );
    destroyDataStructure(data);
 
    return 0;
}

déjà tu peux simplifier :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
char *myStrCpy( const char *string )
{
    char *newString = (char *)malloc( (strlen(string)+1)*sizeof(char) );
 
    if ( newString != NULL )
    {
        size_t i;
        for ( i=0 ; i<strlen(string) ; i++ )
        {
            newString[i] = string[i];
        }
 
        newString[i] = '\0';
    }
 
    else
    {
        free(newString);
        exit(-1);
    }
 
    return newString;
}

par

Code:

1
2
3
4
5
6
char *myStrCpy( const char *string )
{
    char *newString = strdup(string);
 
    return newString;
}

:P

et même éliminer complètement et remplacer par strdup directement...

19/04/2011, 07h25
Thierry Chappuis

Bon, strdup() ne fait pas partie de la bibliothèque standard comme définie par C90. C'est une fonction Posix.1, certes très portable, mais pas présente sur tous les systèmes. Sa réimplantation n'est, il est vrai, pas une grosse affaire et ressemble comme deux gouttes d'eau au code proposé par le PO deux posts plus haut.

Thierry

et tu ne crois pas que :
Code:

1 2 3 4 for ( i=0 ; i<strlen(string) ; i++ ) { newString[i] = string[i]; }
serait avatageusement remplacé par :

Code:

memcpy ( newstring, string, strlen(string) );

?

Personnellement, je remplacerais:

Code:

1
2
3
4
5
6
for ( i=0 ; i<strlen(string) ; i++ )
{
    newString[i] = string[i];
}
 
newString[i] = '\0';

par

Code:

1
2
newString[] = '\0';
strcat(newString, string);

Mon implantation de strdup() devient par conséquent:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
char *m_strdup(const char *s)
{
    char *s_ret = NULL;
 
    if (s != NULL)
    {
        size_t slen = strlen(s) + 1;
        s_ret = malloc(slen * sizeof *s_ret);
        if (s_ret != NULL)
        {
            *s_ret = '\0';
            strcat(s_ret, s);
        }
    }
 
    return s_ret;
}

Avec mes meilleures salutations

Thierry

19/04/2011, 13h45
Thierry Chappuis
Au passage:
Code:

1 2 3 4 5 6 7 8 testRealloc = realloc( testRealloc, (i+1)*sizeof(int)); if ( testRealloc != NULL ) { *ptr = testRealloc; (*ptr)[i] = i; }
Il est généralement déconseillé, avec realloc(), d'utiliser la même variable (testRealloc) à gauche et à droite de l'affectation. En effet, en cas d'échec de la réallocation de mémoire, testRealloc reçoit la valeur NULL. L'adresse de l'ancien espace mémoire pointée par testRealloc est perdue et l'espace mémoire correspondant n'est pas libéré.

Il est préférable de faire:
Code:

1 2 3 4 5 6 7 8 9 int *tmp = NULL; tmp = realloc( testRealloc, (i+1) * sizeof *tmp; if ( tmp != NULL ) { testRealloc = tmp; /* ... */ }
Par ailleurs, même si ton code est destiné à tester le fonctionnement de la fonction realloc(), il n'est pas judicieux (et surtout très peu efficace) dans la vraie vie de réallouer à chaque fois pour une "case mémoire" en plus. Une bonne stratégie est de multiplier par un facteur 1.5 (voir par exemple realloc.pdf ) l'espace mémoire précédemment alloué à chaque appel de realloc() et de ne réallouer que lorsque c'est nécessaire.

Intéressant ces remarques sur realloc.

Je suis confronté à un nouveau problème.
Je reçois le signal SIGSEV quand j'essaye de remplir mon tableau de structures.
En effet je constate que quelque chose cloche dans ma manière d'allouer dans mes structures.
Pourtant je vérifie le retour de malloc à chaque allocation. Cependant, le programme continuer de s'exécuter. Ce qui veut dire que mon allocation semble correcte mais cela en supposant que mes conditions soient corrects.
J'ai remarqué que le programme plantait là où le code est en rouge dans cette fonction quand j'essaye d'accéder à ma structure de structure une fois que l'allocation est terminée pour initialiser les variables :

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
t_sphere *createSphereStructure( size_t nodeNumber )
{
    t_sphere *sphere = (t_sphere*)malloc(sizeof(t_sphere));

    if ( sphere != NULL )
    {
        sphere->sphericalCoordinate = (t_scoord*)malloc( nodeNumber*sizeof(t_scoord) );

        if ( sphere->sphericalCoordinate == NULL )
        {
            free(sphere->sphericalCoordinate);
            free(sphere);
            exit(-1);
        }

        else
        {
            sphere->cartesianCoordinate = (t_ccoord*)malloc( nodeNumber*sizeof(t_ccoord) );

            if ( sphere->cartesianCoordinate == NULL )
            {
                free(sphere->sphericalCoordinate);
                free(sphere->cartesianCoordinate);
                free(sphere);
                exit(-1);
            }

            else
            {
                sphere->sphereEquation[0] = 1.;
                sphere->sphereEquation[1] = 1.;
                sphere->sphereEquation[2] = 1.;
                sphere->sphereEquation[3] = 1.;
                sphere->nodeNumber = nodeNumber;
            }
        }
    }

    else
    {
        free(sphere);
        exit(-1);
    }

    size_t i;
    for ( i=0 ; i<nodeNumber ; i++ )
    {
        sphere->sphericalCoordinate[i].teta = 0.;
        sphere->sphericalCoordinate[i].phi  = 0.;
        sphere->cartesianCoordinate[i].x    = 0.;
        sphere->cartesianCoordinate[i].y    = 0.;
        sphere->cartesianCoordinate[i].z    = 0.;
    }

    displayCoordinates( sphere, 's');
    displayCoordinates( sphere, 'c');

    return sphere;
}

Si besoin, le code complet :

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
159
160
161
162
163
164
165
166
167
168
/**********************************************************************************************************/
/*                                        Structure de données                                            */
/**********************************************************************************************************/
 
typedef struct  /* Position angulaire du noeud sur la sphere */
{
    float teta;    /* Position angulaire du noeud entre l'axe z->y */
    float phi;     /* Position angulaire du noeud entre l'axe x->y */
}t_scoord;
 
typedef struct  /* Coordonnées cartésienne du noeud sur la sphere */
{
    float x;       /* Coordonnée du noeud sur l'axe x */
    float y;       /* Coordonnée du noeud sur l'axe y */
    float z;       /* Coordonnée du noeud sur l'axe z */
}t_ccoord;
 
typedef struct
{
    float sphereEquation[3];          /* Tableau qui stocke les coefficients de l'équation de la sphere */
    t_scoord *sphericalCoordinate;    /* Coordonnées sphériques des noeuds sur la sphere                */
    t_ccoord *cartesianCoordinate;    /* Coordonnées cartésiennes des noeuds sur la sphere              */
    size_t nodeNumber;                /* Nombre de noeuds disposés sur la sphere                        */
}t_sphere;
 
 
 
/**********************************************************************************************************/
/*                         Sous fouctions de la fonction principale du module                             */
/**********************************************************************************************************/
 
t_sphere *createSphereStructure( size_t nodeNumber )
{
    t_sphere *sphere = (t_sphere*)malloc(sizeof(t_sphere));
 
    if ( sphere != NULL )
    {
        sphere->sphericalCoordinate = (t_scoord*)malloc( nodeNumber*sizeof(t_scoord) );
 
        if ( sphere->sphericalCoordinate == NULL )
        {
            free(sphere->sphericalCoordinate);
            free(sphere);
            exit(-1);
        }
 
        else
        {
            sphere->cartesianCoordinate = (t_ccoord*)malloc( nodeNumber*sizeof(t_ccoord) );
 
            if ( sphere->cartesianCoordinate == NULL )
            {
                free(sphere->sphericalCoordinate);
                free(sphere->cartesianCoordinate);
                free(sphere);
                exit(-1);
            }
 
            else
            {
                sphere->sphereEquation[0] = 1.;
                sphere->sphereEquation[1] = 1.;
                sphere->sphereEquation[2] = 1.;
                sphere->sphereEquation[3] = 1.;
                sphere->nodeNumber = nodeNumber;
            }
        }
    }
 
    else
    {
        free(sphere);
        exit(-1);
    }
 
    size_t i;
    for ( i=0 ; i<nodeNumber ; i++ )
    {
        sphere->sphericalCoordinate[i].teta = 0.;
        sphere->sphericalCoordinate[i].phi  = 0.;
        sphere->cartesianCoordinate[i].x    = 0.;
        sphere->cartesianCoordinate[i].y    = 0.;
        sphere->cartesianCoordinate[i].z    = 0.;
    }
 
    displayCoordinates( sphere, 's');
    displayCoordinates( sphere, 'c');
 
    return sphere;
}
 
void destroySphereStructure( t_sphere *sphere )
{
    free(sphere->sphericalCoordinate);
    free(sphere->cartesianCoordinate);
    free(sphere);
}
 
/* Fonction qui vérifie que deux noeud n'ont pas les mêmes coordonnées */
unsigned int areCoordinateAvailable( t_scoord *coordinate, float teta, float phi, size_t I )
{
    unsigned int areAvailable = 0;
 
    if ( I == 0 )
    {
        areAvailable = 1;
        printf("OK");
    }
 
    else
    {
        size_t i;
        for ( i=0 ; i<I ; i++ )
        {
            if ( coordinate[i].teta == teta && coordinate[i].phi == phi )
            {
                return 0;
            }
        }
 
        areAvailable = 1;
    }
 
    return areAvailable;
}
 
/* Fonction qui génère pour chaque noeud des positions aléatoires sur la sphere */
void getRandomCoordinates( t_sphere *sphere )
{
    size_t i;
 
    /* Pour chaque noeud, on génere une position angulaire aléatoire sur la sphere */
    for ( i=0 ; i<sphere->nodeNumber ; i++ )
    {
        float teta = 0;
        float phi  = 0;
 
        unsigned int areAvailable = 0;
        while ( areAvailable == 0 )
        {
            teta = rand()%2*M_PI;
            phi  = rand()%2*M_PI;
 
            /* On vérifie avant qu'un autre noeud ne possède pas déjà ces coordonnées */
            areAvailable = areCoordinateAvailable( sphere->sphericalCoordinate, teta, phi, i);
        }
 
        /* On affecte ces coordonnées au noeud i */
        sphere->sphericalCoordinate[i].teta = teta;
        sphere->sphericalCoordinate[i].phi  = phi ;
    }
}
 
 
 
/**********************************************************************************************************/
/*                                    Fonction principale du module                                       */
/**********************************************************************************************************/
 
t_sphere *getSphereStructure( t_csv *csv, t_similarityMatrix* similarityMatrix )
{
    t_sphere *sphere = createSphereStructure( csv->line-3 );
 
    getRandomCoordinates(sphere);
 
    return sphere;
 
}

Merci d'avance.

Code:

1 2 3 4 5 6 7 typedef struct { float sphereEquation[3]; /* Tableau qui stocke les coefficients de l'équation de la sphere */ t_scoord *sphericalCoordinate; /* Coordonnées sphériques des noeuds sur la sphere */ t_ccoord *cartesianCoordinate; /* Coordonnées cartésiennes des noeuds sur la sphere */ size_t nodeNumber; /* Nombre de noeuds disposés sur la sphere */ }t_sphere;
Le champ sphereEquation de ta structure de type t_sphere est un tableau de 3 éléments. Or, ici:
Code:

1 2 3 4 sphere->sphereEquation[0] = 1.; sphere->sphereEquation[1] = 1.; sphere->sphereEquation[2] = 1.; sphere->sphereEquation[3] = 1.;
tu stockes 4 éléments dans ton tableau. sphereEquation[3] est hors limite et engendre probablement l'erreur de segmentation, ou en tout cas, il y a une erreur à ce niveau. Je ne vois à priori pas d'autre problème dans ta fonction createSphereStructure(). Les appels à exit() ne me plaisent pas plus que tant, mais ce n'ai pas le sujet de ce fil de disserter sur la gestion des erreurs.

Avec mes meilleures salutations

Thierry

19/04/2011, 18h31
darkwall_37

Merci merci, c'est ça ! Je me fais de la peine à faire encore des erreurs pareilles ! BRAIN's BURNOUT :D. Quant à la gestion des erreurs, j'avoue je ne me suis pas encore penché sur une gestion propre, il va falloir que j'apprenne tôt ou tard parce qu'il est vrai que c'est un peu crado exit ^^