Structure et realloc

**darkwall_37** · 15/04/2011, 15h50

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 :

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

void T1( t_data *data )

Code :

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

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 :

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

char ***allocateCSV( t_data *data )

Code :

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

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

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

Voici le code intégrale :

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

**jeroman** · 15/04/2011, 18h20

Salut

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

Code :

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

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

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

Code :

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

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 :

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

data->(*allocateCell) = testRealloc;

ce serait plutôt

Code :

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

data->allocateCell  = testRealloc;

Code :

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

exit(...);

Je dirais : à bannir.

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.

**darkwall_37** · 15/04/2011, 18h47

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.

**diogene** · 15/04/2011, 19h07

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

En écrivant

Code :

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

data->(*allocateCell)

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

**darkwall_37** · 17/04/2011, 02h09

Envoyé par jeroman

Salut

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

Code :

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

exit(...);

Je dirais : à bannir.

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 :

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

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

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

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

**souviron34** · 18/04/2011, 13h22

déjà tu peux simplifier :

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

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

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

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

**Thierry Chappuis** · 19/04/2011, 07h25

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

**souviron34** · 19/04/2011, 10h24

et tu ne crois pas que :

Code :

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

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

serait avatageusement remplacé par :

Code :

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

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

?

Structure et realloc

C

Vue hybride

Discussions similaires

Partager

Partager