Discussion :

[azez]

Bonjour,

en ce moment je travaille sur un programme de calcul scientifique qui utilise beaucoup de tableaux à 4 dimensions , alors au lieu "d'alloquer" chaque fois un tableau et répéter le code, j'ai construit une fonction qui fait l'allocation dynamique de tableux 4D; c'est la suivante :

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
 
#include <stdlib.h>
float ****AllocfloatTab4D(int dim1, int dim2, int dim3, int dim4)
{
    int i, j, k;
    float ****p;
    if ((p = (float ****)malloc(dim1*sizeof(float ***))) == NULL)
       return NULL;
    for (i = 0; i < dim1; i++) {
        if ((p[i] = (float ***)malloc(dim2*sizeof(float **))) == NULL)
           return NULL;
        for (j = 0; j < dim2; j++)
            if ((p[i][j] = (float **)malloc(dim3*sizeof(float *))) == NULL)
               return NULL;
            for (k = 0; k < dim3; k++)
                if ((p[i][j][k] = (float *)malloc(dim4*sizeof(float ))) == NULL)
                   return NULL;
    }
    return p;
} 
//

je peux l'utiliser par exemple comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
 
int main()
{
     float ****tab;
     if ((tab = AllocfloatTab4D(10, 15, 20, 25)) != NULL)
     tab[5][7][0][3] = 0;
     // ...... 
}
//

le prblème :
1- est ce que la fonction est correcte?
2- comment faire la fonction inverse " DeallocfloatTab4D" qui d'aprés son nom fait le travail inverse c-à-d libérer la mémoire allouer par la fonction "AllocfloatTab4D" ?

merci d'avance.

[Gruik]

Salux,

1) On dirait que oui
2) Bon j'ai presque jamais utilisé les tableaux multidimentionnels et ça a surement une utilité dans des appli scientifiques, mais si j'étais toi je ferais un type abstrait pour gerer ces tableaux 4D. Il serait implementé par un tableau 1D et tout serait plus simple.

Pour acceder à un element, on aurait un getter et un setter de ce genre là

Code :

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

1
2
float tab4d_get(const Tableau4D * tab4d, int x, int y, int z, int w);
void tab4d_set(Tableau4D * tab4d, int x, int y, int z, int w, float valeur);

[Médinoc]

Tu risques de rapidement t'y perdre avec toutes ces boucles.
Tu dois avoir le moyen de ne réaliser qu'une allocation par dimension. Je l'ai souvent fait avec deux, mais cela ne doit pas être beaucoup plus difficile de le faire avec quatre...

[azez]

merci Gruik et Médinoc,

@ Gruik : merci de ton idée concernant la création d'un type abstrait mais là j'aimerai bien utiliser les tableux dynamiques car je viens juste de un peu les comprendre

@ Médinoc : c'est ce que je fais une allocation par dimension soit 4 allocations pour un tableau de 4D.

voilà j'ai ecrit ce code pour la fonction FreefloatTab4D qui fait libérer la mémoire allouée par la fonction précedente :

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
 
#include <stdlib.h>
 
void FreefloatTab4D(NomTab, int dim1, int dim2, int dim3, int dim4) // la question : comment dois je déclarer NomTab qui est le nom du tableau a étre libéré?
{   
if ( NomTab != Null )
{
    int i, j, k;
    for (i = 0; i < dim1; i++)
    {
        for (j = 0; j < dim2; j++)
        { 
            for (k = 0; k < dim3; k++)
            {
                free (NomTab[i][j][k]);
            }
            free (NomTab[i][j]);
        }
        free (NomTab[i]);
    }
    free (NomTab);
}
}
//

questions :
1- comment puis je déclarer la variable NomTab qui correspende au nom du tableau a libérer ?

2- est ce que le principe de cette fonction est correct ?

merci bien.

[Médinoc]

@ Médinoc : c'est ce que je fais une allocation par dimension soit 4 allocations pour un tableau de 4D.

On dirait pas :
Vu ton code, tu fais 1 + dim1 + dim1*dim2 + dim1*dim2*dim3 allocations, ce qui fait beaucoup plus que quatre...

[Thierry Chappuis]

J'y ai pas beaucoup réfléchi, mais je ne vois pas comment se présente ta solution à 4 allocations? Je vois comment faire avec une alloc.

Thierry

[souviron34]

2- comment faire la fonction inverse " DeallocfloatTab4D" qui d'aprés son nom fait le travail inverse c-à-d libérer la mémoire allouer par la fonction "AllocfloatTab4D" ?

merci d'avance.

Si tu tiens ABSOLUMENT à le faire avec u n tel tableau, il n'y a qu'une seule solution :

il faut libérer du plus profond au plus haut, et en plus si possbile dans l'ordre d'allocation c'est encore mieux :

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
 
    for (i = (dim1-1) ; i >= 0 ; i--) 
       {
          for (j = (dim2-1) ; j >= 0 ; j--)
             {
                for (k = (dim3 -1) ; k >= 0 ; k--)
                    free(p[i][j][k]);
 
                free(p[i][j]);
             }
 
           free(p[i]);
      }
 
  free(p);

[Thierry Chappuis]

Salut,

Ce qui me gène dans ta fonction AllocfloatTab4D(), c'est que lorsqu'un allocation échoue, tu quittes la fonction sans faire le ménage de ce qui a déjà été alloué... C'est pas très propre!.

J'ai mis un exemple de tableau 3D sur ton autre post. La programmation d'un tableau à 4 dimensions se fait selon le même schéma. Toutefois, comme l'a dit Gruik, utiliser un type abstrait de donnée (TAD) permettrait de te simplifier la vie. Tu pourrais par exemple utiliser la structure suivante:

Code :

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

1
2
3
4
5
6
7
typedef Array4D_ {
    double *array; /* Tableau 1D de taille dim1xdim2xdim3xdim4 */
    int dim1;
    int dim2;
    int dim3;
    int dim4;
} Array4D_s;

Thierry