Discussion :

[azez]

Bonjour,

je suis débutant et je veux comprendre comment utiliser les tableaux dynamiques 3D, j'ai fait un code qui construit un tableau 3D "A" de dimension axbxc ; a,b et c sont obtenus depuis un fichier taille.dat.

exemple de taille.dat :

Code :

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

2 3 4

mon code est le suivant :

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
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int  a,b,c,i,j,k;
    float ***A; // A est un tableau 3D de taille axbxc
    FILE *f_in;
 
    /*  Lecture des dimensions du tableau depuis un fichier "taille.dat" */
    f_in=fopen("taille.dat","r");
    if (f_in== NULL)
{
    printf("Impossible d'ouvrire le fichier taille.dat");
    exit(1);
}
fscanf(f_in, "%i %i %i\n",&a, &b, &c);
printf("a = %i; b = %i; c = %i\n",a,b,c); // affichage des valeurs de a, b ,c
    /* construction du tableau 3D A */
    A=malloc(sizeof*A*a);
 
     if ( A == NULL )
{
     printf("Allocation impossible \n");
     exit(1);
}
 
  for (i=0;i<a;i++)
  {
      A[i]=malloc(sizeof*A[i]*b);
      for (j=0;j<b;j++)
      {
          A[i][j]=malloc(sizeof*A[i][j]*c);
      }
  }
 
/* Initialisation de tous les éléments de A à 0 ensuite remplissage de A et affichage */
for (i=0;i<a;i++)
  {
      for (j=0;j<b;j++)
      {
          for (k=0;k<c;k++)
          {
 
               A[i][j][k]=0; // initialisation de tous les éléments de A
               A[i][j][k]=A[i][j][k]+0.5; // exemple d'operation sur les éléments de A
               printf("A[%i][%i][%i] = %f\n", i, j,k, A[i][j][k]); // affichage des élément du tableau
          }
 
      }
  }
free(A);
return 0;
}

le compilateur signale des erreurs :

Code :

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

1
2
3
4
 
line 20    error: invalid conversion from 'void*' to 'float***'
line 30    error: invalid conversion from 'void*' to 'float**' 
line 33    error: invalid conversion from 'void*' to 'float*'

merci de corriger mon code si c'est possible.

[Fendal]

Si je ne me trompe pas les problèmes correspondent aux lignes des mallocs.
Je dirais qu'il manque les parenthèses :
sizeof(A)*a
sizeof(A[i])*b
sizeof(A[i][j])*c

Je pense qu'il y a aussi un problème sur la dernière ligne car c'est la taille d'un pointeur vers un float qui est alloué et non la taille d'un float.
(A confirmer, personnellement je n'utilise jamais cette notation de sizeof avec les noms de variables)

[Thierry Chappuis]

Pour le message du compilateur, es-tu certain d'utiliser un compilateur C et non un compilateur C++. Si l'extension de ton fichier source est .C (majuscule), .cpp ou .cxx, il y a de grande chance qu'un compilateur C++ soit utilisé. Or, en C++, la convertion implicite d'un pointeur générique de type void * en n'importe quel autre type de pointeur n'est pas autorisée (alors qu'elle l'est en C). D'où les messages d'erreur...

En ce qui concerne le code proprement dit, je ne vois d'erreur flagrante. Je suis en train de tester...

Thierry

[azez]

grand merci à Fendal et mujigka,

oui c'est les lignes des mallocs la conversion de types ne se fait pas malgré que j'utilise l'EDI code::blocks v1.0 contenant un compilateur c ( l'extension de mon source est c miniscule)

j'ai corrigé mon code comme suit :

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
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int  a,b,c,i,j,k;
    float ***A; // A est un tableau 3D de taille axbxc
    FILE *f_in;
 
    /*  Lecture des dimensions du tableau depuis un fichier "taille.dat" */
    f_in=fopen("taille.dat","r");
    if (f_in== NULL)
{
    printf("Impossible d'ouvrire le fichier taille.dat");
    exit(1);
}
fscanf(f_in, "%i %i %i\n",&a, &b, &c);
printf("a = %i; b = %i; c = %i\n",a,b,c); // affichage des valeurs de a, b ,c
    /* construction du tableau 3D A */
    A = (float***)malloc(sizeof(float**) *a);
 
     if ( A == NULL )
{
     printf("Allocation impossible \n");
     exit(1);
}
 
  for (i=0;i<a;i++)
  {
      A[i] = (float**)malloc(sizeof(float*) *b);
      for (j=0;j<b;j++)
      {
          A[i][j] = (float*)malloc(sizeof(float)*c);
      }
  }
 
/* Initialisation de tous les éléments de A à 0 ensuite remplissage de A et affichage */
for (i=0;i<a;i++)
  {
      for (j=0;j<b;j++)
      {
          for (k=0;k<c;k++)
          {
 
               A[i][j][k]=0; // initialisation de tous les éléments de A
               A[i][j][k]=A[i][j][k]+0.5; // exemple d'operation sur les éléments de A
               printf("A[%i][%i][%i] = %f\n", i, j,k, A[i][j][k]); // affichage des élément du tableau
          }
 
      }
  }
free(A);
return 0;
}

et ça marche !!!

dernière question : est ce que je fais bien la libération de la mémoire ??

[stephl]

dernière question : est ce que je fais bien la libération de la mémoire ??

Non, free(A) ne suffit pas. A chaque malloc() doit correspondre un free(). Attention à l'ordre.

[azez]

Non, free(A) ne suffit pas. A chaque malloc() doit correspondre un free(). Attention à l'ordre.

alors je dois ajouter deux free() ?

c-à-d :

Code :

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

1
2
3
4
 
free(A[i][j]);     // est ce que ces deux free() doivent étre dans les  ...
free(A[i]);       // ...  boucles (i,j) où bien à la fin du code comme ça ?
free(A);

svp les deux free() contenant les indices i et j où dois je les mettre ?

merci.

[stephl]

alors je dois ajouter deux free() ?

c-à-d :

Code :

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

1
2
3
4
 
free(A[i]);     // est ce que ces ...
free(A[i][j]);  // ... deux free() doivent étre dans les boucles (i,j) où bien à la fin du code comme ça ?
free(A);

Comme cela:

Code :

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

1
2
3
4
5
6
7
for (i=0;i<a;i++)
  {
      for (j=0;j<b;j++)
          free(A[i][j]);
  free(A[i]);
  }
free(A);

[azez]

merci beaucoup stephl ,

j'ai finalement compris

question : j'ai téster les valeurs des éléments de A aprés les mallocs et il sont tous à 0 c-à-d pas la peine d'initialiser les élément manuellement ?

[femtosa]

Pense au tag

[stephl]

merci beaucoup stephl ,

j'ai finalement compris

question : j'ai téster les valeurs des éléments de A aprés les mallocs et il sont tous à 0 c-à-d pas la peine d'initialiser les élément manuellement ?

Si. Avec malloc(), l'espace alloué n'est pas mis à zéro. Il peut contenir n'importe quoi.

[azez]

grand merci à tous

[Thierry Chappuis]

Salut,

Pourquoi as-tu ajouter des casts aux valeurs retournées par malloc, et remplacé tes sizeof *A, sizeof *A[i] et sizeof *A[i][j] par sizeof(float **), sizeof(float *) et sizeof(float) respectivement. C'était (à peu de choses près) mieux avant...

Malgré le fait que tu utilises Code::Blocks et la suite de compilateurs MinGW (port Windows de GCC), je persiste à penser que c'est le compilateur C++ de MinGW qui est utilisé pour la compilation à cause d'une mauvaise extention de fichier (.cpp au lieu de .c). C'est la raison pour laquelle, à mon avis, tu obtenais les messages d'erreur mentionnés dans le 1er post. La solution à ce problème n'est pas de caster la valeur de retour de *alloc(), mais bien de t'assurer que c'est bien le compilateur C qui est utilisé (ou alors de programmer effectivement en C++, mais alors là, plus de malloc).

A part cela, une grande faiblesse de ton code est que tu ne vérifies pas la valeur de retour de malloc() (sauf après le 1er appel). C'est une erreur, car une allocation mémoire est toujours susceptible d'échouer. Voici un code d'une fonction que j'ai utilisée il y a quelques temps pour me familiariser avec l'allocation dynamique de tableaux multi-dimensionnels. Ce n'est qu'un exemple:

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
#include <stdio.h>
#include <stdlib.h>
 
/* En général, ce n'est pas une bonne idée de discriminer les compilateur 
    C++ de cette manière */
#ifdef __cplusplus
#error "Ce code ne compile pas avec un compilateur C++!"
#endif
 
#define N 3
 
/* Codes d'erreur retournés par la fonction array3D_dbl_arr_alloc() */
typedef enum Array3D_dbl_err_ {
    ARRAY3D_OK,
    ARRAY3D_ERR_NULL_ARG,
    ARRAY3D_ERR_SIZE,
    ARRAY3D_ERR_MEMORY,
    ARRAY3D_UNKNOWN
} Array3D_dbl_err_e;
 
/**
 * Creation et allocation dynamique d'un tableau à 3 dimensions de nombres flottants
 * de type double.
 */ 
static Array3D_dbl_err_e array3D_dbl_arr_alloc(double ****array, int a, int b, int c);
/**
 * Libération d'un tableau à 3D créé par array3D_dbl_arr_alloc()
 */ 
static void array3D_dbl_arr_free(double ****array, int a, int b, int c);
/**
 * Affichage d'un tableau à 3D créé par array3D_dbl_arr_alloc()
 */  
static void array3D_dbl_display(double ***array, int a, int b, int c);
 
/* Point d'entrée principal ======================== */
 
int main(void)
{
    int err = EXIT_SUCCESS;
 
    int err_val = ARRAY3D_OK;
    double ***arr = NULL;
 
    /* Allocation et initialisation du tableau à 3 dimensions */
    err_val = array3D_dbl_arr_alloc(&arr, N, N, N);
 
    if (err_val == ARRAY3D_OK)
    { 
        /* -tc- Allocation OK: on affiche le tableau 3D  */
        array3D_dbl_display(arr, N, N, N);
 
        /*-tc- On fait plein de choses avec notre tableau... */
 
        /*-tc- Finallement, on oublie pas de libérer la mémoire allouée */
        array3D_dbl_arr_free(&arr, N, N, N);
    }
    else
    {
        fprintf(stderr, "Problème d'allocation!");
        err = EXIT_FAILURE;
    }
    return err;
}
 
/* Fonctions privées ============================= */
 
static Array3D_dbl_err_e
array3D_dbl_arr_alloc(double ****array, int a, int b, int c)
{
    /*-tc- initialisation du code d'erreur */
    int err = ARRAY3D_OK;
 
    if (array != NULL)
    {
        double ***A = NULL;
 
        if (a > 0 && b > 0 && c > 0)
        {
            int i, j, k; /* -tc- indices de boucles */
 
            A = malloc(a * sizeof *A);
            if (A != NULL)
            {
                /*-tc- allocation de mémoire ok! */
                for (i = 0; i < a && err == ARRAY3D_OK; ++i)
                {
                    A[i] = malloc(b * sizeof *A[i]);
                    if (A[i] != NULL)
                    {
                        /*-tc- allocation de mémoire ok */
                        for (j = 0; j < b && err == ARRAY3D_OK; ++j)
                        {
                            A[i][j] = malloc(c * sizeof *A[i][j]);
                            if (A[i][j] != NULL)
                            {
                                /*-tc- allocation de mémoire ok */
                                for (k = 0; k < c; ++k)
                                {
                                    /*-tc- initialisation des cases du tableau */
                                    A[i][j][k] = 0.0;
                                }
                            }
                            else
                            {
                                /*-tc- erreur d'allocation mémoire. On libère tout
                                   ce qui a été alloué jusque là */
                                while (j-- > 0)
                                {
                                    free(A[i][j]);
                                }
                                free(A[i]);
 
                                while (i-- > 0)
                                {
                                    j = b;
                                    while (j-- > 0)
                                    {
                                        free(A[i][j]);
                                    }
                                    free(A[i]);
                                }
                                free(A), A = NULL;
 
                                /*-tc- on retourne un code d'erreur approprié */
                                err = ARRAY3D_ERR_MEMORY;
                            }
                        }
                    }
                    else
                    {
                        /* -tc- erreur d'allocation mémoire. On libère tout
                            ce qui a été alloué jusque là */
                        while (i-- > 0)
                        {
                            free(A[i]);
                        }
                        free(A), A = NULL;
 
                        /*-tc- on retourne un code d'erreur approprié */
                        err = ARRAY3D_ERR_MEMORY;
                    }
                }
            }
            else
            {
                /*-tc- erreur d'allocation mémoire */
                err = ARRAY3D_ERR_MEMORY;
            }
        }
        else
        {
            /* -tc- erreur: des dimensions du tableau doivent être 
                strictement positives*/
            err = ARRAY3D_ERR_SIZE;
        }
        *array = A;
    }
    else
    {
        /* -tc- erreur: NULL est passé en premier argument de la fonction */
        err = ARRAY3D_ERR_NULL_ARG;
    }
    return err;
}
 
static void
array3D_dbl_arr_free(double ****array, int a, int b, int c)
{
    if (array != NULL)
    {
        int i, j;
        double ***A = *array;
 
        for (i = 0; i < a && A[i] != NULL; ++i)
        {
            for (j = 0; j < b && A[i][j] != NULL; ++j)
            {
                free(A[i][j]);
            }
            free(A[i]);
        }
        free(A);
        *array = NULL;
    }
 
    (void) c; /* unused parameter */
}
 
void
array3D_dbl_display(double ***array, int a, int b, int c)
{
    if (array != NULL)
    {
        int i, j, k;
 
        if (a > 0 && b > 0 && c > 0)
        {
            for (i = 0; i < a; ++i)
            {
                for (j = 0; j < b; ++j)
                {
                    for (k = 0; k < c; ++k)
                    {
                        printf("%.2f ", array[i][j][k]);
                        if (k == c - 1)
                        {
                            printf("\n");
                        }
                    }
                    if (j == b - 1)
                    {
                        printf("\n");
                    }
                }
            }
        }
    }
}

En pratique pour éviter de passer à chaque fonction un argument de type double *** ou double ****, ainsi que la taille des 3 dimensions, je préfère encapsuler le tout dans une structure et construire un type abstrait de donnée (TAD):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct Array3D_dbl_ Array3D_dbl_s;
struct Array3D_dbl_ {
    double ***arr; /* Tableau à 3 dimentions */
    int a; /* Dimension 1 */
    int b; /* Dimension 2 */
    int c; /* Dimension 3 */
};
 
Array3D_dbl_err_e array3D_dbl_new(Array3D_dbl_s **pp_self, int a, int b, int c);
void array3D_dbl_delete(Array3D_dbl_s **pp_self);
void array3D_dbl_display(Array3D_dbl_s *p_self);
/* + n'importe quelle autre fonction de manipulation d'un tableau 3D */

L'utilisation d'un TAD peut également te permettre de simplifier la programmation d'un tel tableau à 3 dimensions en créant, par exemple, une structure contenant un tableau 1D de taille a x b x c:

Code :

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

1
2
3
4
5
6
7
typedef struct Array3D_dbl_ Array3D_dbl_s;
struct Array3D_dbl_ {
    double *arr; /* Tableau à 1 dimentions de taille axbxc */
    int a; /* Dimension 1 */
    int b; /* Dimension 2 */
    int c; /* Dimension 3 */
};

L'accès aux différentes cases du tableau est alors géré par des fonctions avec le prototype suivant:

Code :

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

double array3D_dbl_get_value(Array3D_dbl_s const *p_self, int a, int b, int c);

Thierry

[azez]

Encore merci Thierry de ta précieuse aide, je vais si tu me le permet d'utiliser tes fonctions car tu géres trés bien les erreurs.

Thierry a ecrit :

je persiste à penser que c'est le compilateur C++ de MinGW

oui tu as raison la preuve le compilateur ma donné l'erreur que tu as préciser dans ton code ( à propos du compilo C++);

alors comment faire pour installer un compilo C dans code::blocks et l'utiliser ?

[Ulmo]

[...]je persiste à penser que c'est le compilateur C++ de MinGW qui est utilisé pour la compilation à cause d'une mauvaise extention de fichier (.cpp au lieu de .c).

Il suffit donc de renommer ton fichier.

[azez]

le fichier est ".c" (c miniscule) et malgrés ça il me fait les mémes erreurs lors de la compilation .

[Médinoc]

Ajoute ceci au début du fichier.

Code C :

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

1
2
3
#ifdef __cplusplus
#error Tentative de compiler du C avec un compilo C++
#endif

S'il y a une erreur, il faut fouiller dans les options du projet pour trouver quelque part une option qui force la compilation C++ du fichier C, et la désactiver.

[Thierry Chappuis]

le fichier est ".c" (c miniscule) et malgrés ça il me fait les mémes erreurs lors de la compilation .

Lors de la création du projet, as-tu précisé que tu désirais créer un projet C et non un projet C++. En effet, lorsque je crée un projet console C++, et que renomme le fichier main.cpp du template en main.c, le compilateur C++ est toujours utilisé. Je n'ai pas trouvé où désactiver cette option dans le projet (si quelqu'un a une idée, je suis preneur, bien que je n'utilise pas souvent Code::Blocks).

Le plus simple est bien entendu de créer un projet C (et non C++) dès le départ... Pour cela, soit tu crées par exemple un projet Console, et tu sélectionne l'option C lorsque Code::Blocks te pose la question "Please select the language you want to use". Une autre solution est de créer un projet vide (Empty projet) et d'y ajouter un fichier avec l'extension .c. Avec cela, aucun soucis quant à l'identité du compilateur utilisé.

Thierry

[azez]

salut Thierry,

oui tu as raison, je ne faisais pas un nouveau projet ; je faisais directement "New File" en lui donnant .c comme extension , et oui dans ce cas le compilateur c++ est utilisé.

la solution comme tu as dit : créer un projet et choisir dés le debut le compilateur c.

merci beaucoup.

[Thierry Chappuis]

salut Thierry,

oui tu as raison, je ne faisais pas un nouveau projet ; je faisais directement "New File" en lui donnant .c comme extension , et oui dans ce cas le compilateur c++ est utilisé.

la solution comme tu as dit : créer un projet et choisir dés le debut le compilateur c.

merci beaucoup.

N'oublie donc pas le tag . Si toutefois quelqu'un as une idée de comment transformer dans Code::Blocks un projet C++ en projet C après sa création via les propriétés du projet, je suis preneur, mais il y a un forum pour cela. Ce n'est probablement pas le lieu d'en débattre.

EDIT: chez moi, lorsque je crée un fichier test.c isolé dans Code::Blocks, il n'y a aucun problème, le compilateur C est utilisé...

Thierry