Fonction Deallocate tableau 4D

**azez** · 17/04/2007, 19h56

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** · 17/04/2007, 21h13

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** · 17/04/2007, 22h50

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** · 18/04/2007, 01h05

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.

**souviron34** · 18/04/2007, 01h06

Envoyé par azez

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** · 18/04/2007, 02h02

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

**Médinoc** · 18/04/2007, 10h35

Envoyé par azez

@ 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** · 18/04/2007, 11h13

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

**Médinoc** · 18/04/2007, 11h22

Une alloc de dim1 T***
Une alloc de dim1*dim2 T**
Une alloc de dim1*dim2*dim3 T*
Une alloc de dim1*dim2*dim3*dim4 T

Et si les 4 allocs ont réussi, on règle les pointeurs avec des boucles for imbriquées...

**Thierry Chappuis** · 18/04/2007, 12h23

Envoyé par Médinoc

Une alloc de dim1 T***
Une alloc de dim1*dim2 T**
Une alloc de dim1*dim2*dim3 T*
Une alloc de dim1*dim2*dim3*dim4 T

Et si les 4 allocs ont réussi, on règle les pointeurs avec des boucles for imbriquées...

Merci beaucoup

Thierry

**azez** · 18/04/2007, 13h55

Merci bien Thierry, trés jolies fonctions c'est vraiment ce que je voulais, il me reste que passer à la quatrième dimmensien pour avoir des Tab4D.

au fait, je travaille avec environ 30 tableaux 4D, 30 tableaux 3D, 70 tableaux 2D et 10 tableaux 1D ,

la démarche à suivre est de :

1-construire 8 fonction suivant l'exemple de Thierry : c-à-d un couplet de fonctions (alloc, déalloc) pour des TAB 1D ,TAB 2D,TAB 3D et TAB 4D.
2- allouer de la mémoire aux tableaux utilisant la fonction alloc appropriée.
3- faire les calculs sur les éléments des tableaux, et sauvegarder les résultats dans des fichiers texte.
4- libérer la mémoire de chaque tableau utilisant la fonction déaloc appropriée.

est ce que c'est juste tous ça ?

**Thierry Chappuis** · 18/04/2007, 18h28

Envoyé par azez

Merci bien Thierry, trés jolies fonctions c'est vraiment ce que je voulais, il me reste que passer à la quatrième dimmensien pour avoir des Tab4D.

au fait, je travaille avec environ 30 tableaux 4D, 30 tableaux 3D, 70 tableaux 2D et 10 tableaux 1D ,

la démarche à suivre est de :

1-construire 8 fonction suivant l'exemple de Thierry : c-à-d un couplet de fonctions (alloc, déalloc) pour des TAB 1D ,TAB 2D,TAB 3D et TAB 4D.
2- allouer de la mémoire aux tableaux utilisant la fonction alloc appropriée.
3- faire les calculs sur les éléments des tableaux, et sauvegarder les résultats dans des fichiers texte.
4- libérer la mémoire de chaque tableau utilisant la fonction déaloc appropriée.

est ce que c'est juste tous ça ?

En pratique, je n'utilise pas les fonctions que j'ai postées pour manipuler des matrices, tenseurs, etc. (j'ai jamais eu à utiliser de tableau 4D). Je préfère en général passer par un TAD moins gournant en allocations (et moins complexe à gérer).

Thierry

**Médinoc** · 18/04/2007, 18h43

Le plus difficile quand on fait autant d'allocations, c'est de bien tout désallouer en cas d'échec en cours de route.

Se limiter à une allocation par dimension permet de ne faire aucune allocation dans les boucles for: Dans la technique que j'ai décrite, les boucles for ne sont exécutées que si toutes les allocations ont réussi...

**azez** · 18/04/2007, 21h22

salut,

@Médinoc : peux tu me donner un exemple de code utilisant ta méthode stp par ce que là je comprends pas

**Thierry Chappuis** · 18/04/2007, 21h56

Envoyé par azez

salut,

@Médinoc : peux tu me donner un exemple de code utilisant ta méthode stp par ce que là je comprends pas

Voici 5 stratégies possibles pour allouer dynamiquement un tableau 2D:
http://c-faq.com/aryptr/dynmuldimary.html

La solution de Médinoc est équivalente à la solution proposée pour array2 dans le lien ci-dessus. Il suffit de l'adapter au cas d'un tableau 3D puis d'un tableau 4D.

EDIT: Voilà un essai pour un tableau 3D de ints (il y a peu de commentaires, mais je vais essayer d'améliorer la situation).

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
#include <stdio.h>
#include <stdlib.h>
 
typedef enum Array3d_err_ {
    ARRAY3D_OK,
    ARRAY3D_ERR_NULL_ARG,
    ARRAY3D_ERR_SIZE,
    ARRAY3D_ERR_MEMORY,
    ARRAY3D_ERR_UNKNOWN
} Array3d_err_e;
 
static int array3d_new(int ****array, int a, int b, int c)
{
    int err = ARRAY3D_OK;
 
    if (array != NULL)
    {
        if (a > 0 && b > 0 && c > 0)
        {
            int ***self = NULL;
 
            self = malloc(a * sizeof *self);
            if (self != NULL)
            {
                self[0] = malloc(a * b * sizeof *self[0]);
                if (self[0] != NULL)
                {
                    int i;
 
                    for (i = 1; i < a; ++i)
                    {
                        self[i] = self[0] + i * b;
                    }
 
                    self[0][0] = malloc(a * b * c * sizeof *self[0][0]);
                    if (self[0][0] != NULL)
                    {
                        for (i = 1; i < a * b; ++i)
                        {
                            self[0][i] = self[0][0] + i * c;
                        }
 
                        /* Maintenant, on initialise le tout à 0 */
                        for (i = 0; i < a * b * c; ++i)
                        {
                            self[0][0][i] = 0.0;
                        }
 
                        *array = self;
                    }
                    else
                    {
                        free(self[0]);
                        free(self), self = NULL;
                        err = ARRAY3D_ERR_MEMORY;
                    }
                }
                else
                {
                    free(self), self = NULL;
                    err = ARRAY3D_ERR_MEMORY;
                }
            }
            else
            {
                err = ARRAY3D_ERR_MEMORY;
            }
        }
        else
        {
            err = ARRAY3D_ERR_SIZE;
        }
    }
    else
    {
        err = ARRAY3D_ERR_NULL_ARG;
    }
    return err;
}
 
static void array3d_display(int ***array, int a, int b, int c)
{
    if (array != NULL && a > 0 && b > 0 && c > 0)
    {
        int i;
 
        for (i = 0; i < a * b * c; ++i)
        {
            printf("%d ", array[0][0][i]);
            if (i != 0 && i % c == c - 1)
            {
                printf("\n");
                if (i % (b * c) == b * c -1)
                {
                    printf("\n");
                }
            }
        }
    }
}
 
static void array3d_free(int ****array)
{
    if (array != NULL)
    {
        int ***self = *array;
        free(self[0][0]);
        free(self[0]);
        free(self);
        *array = NULL;
    }
}
 
int main(void)
{
    int err = EXIT_SUCCESS;
    int arrerr = ARRAY3D_OK;
    int ***array = NULL;
 
    arrerr = array3d_new(&array, 2, 3, 4);
    if (arrerr == ARRAY3D_OK)
    {
        array3d_display(array, 2, 3, 4);
        array3d_free(&array);
    }
    else
    {
        fprintf(stderr, "Erreur d'allocation!\n");
        err = EXIT_FAILURE;
    }
 
    return err;
}

Thierry

**azez** · 19/04/2007, 10h28

ok maintenant je vois bien le principe merci

deux questions stp :

1-

Code :

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

static int array3d_new(int ****array, int a, int b, int c)

ici pour quoi ****array (4 étoiles)? d'habitude on faisait 3 étoiles pour 3D comme ça ***array.

2- peux tu stp m'aider à construire les mémes fonctions pour un tableau 2D de type complex c-à-d chaqu'un de ses éléments a une partie réelle et une partie imaginaire tous deux de type float?.

**Médinoc** · 19/04/2007, 10h39

C'est parce que la fonction ne retourne pas le pointeur alloué, elle modifie le pointeur passé en paramètre (d'où indirection supplémentaire).
Le mieux, c'est un tableau 2D de structures (pas de pointeurs de structure, mais bien des structures)...

**Thierry Chappuis** · 19/04/2007, 11h04

Envoyé par azez

ok maintenant je vois bien le principe merci

deux questions stp :

1-

Code :

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

static int array3d_new(int ****array, int a, int b, int c)

ici pour quoi ****array (4 étoiles)? d'habitude on faisait 3 étoiles pour 3D comme ça ***array.

2- peux tu stp m'aider à construire les mémes fonctions pour un tableau 2D de type complex c-à-d chaqu'un de ses éléments a une partie réelle et une partie imaginaire tous deux de type float?.

1) La fonction crée dynamiquement un tableau 3D. Pour cela on utilise un pointeur de type int *** qui pointe sur la toute première case du tableau. N'oublie pas qu'en C, le passage des arguments se fait par valeur. Si tu écrit:

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
void fonction(int *tab)
{
    tab =malloc(10 * sizeof *tab)
    if (tab != NULL)
    {
        /* Initialisation du tableau */
    }
}
 
int main(void)
{
    int *mon_tab = NULL;
    fonction(mon_tab);
    if (mon_tab != NULL)
    {
        /* Traitements sur mon_tab */
    }
    else
    {
        /* Message: erreur d'allocation */
    }
 
    return 0;
}

Ce code affiche toujours un message d'erreur, car mon_tab vaut NULL dans tous les cas. En effet, la valeur de tab (NULL) est passée en argument par copie à tab qui est initialisé à NULL. Le code au sein de la fonction modifie la valeur de tab en lui fournissant l'adresse du premier byte d'une zone mémoire de taille 10 * sizeof(int). En revanche, la valeur de mon_tab, elle n'a pas été modifiée, à cause du passage par copie.

Si on désire modifier la valeur de mon tab depuis la fonction, il faut ajouter un niveau d'indirection supplémentaire:

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
void fonction(int **pp_tab)
{
    if (tab != NULL)
    {
        int *p_tab = NULL;
        p_tab =malloc(10 * sizeof *p_tab)
        if (tab != NULL)
        {
            /* Initialisation du tableau */
        }
        *pp_tab = p_tab;
    }
}
 
int main(void)
{
    int *mon_tab = NULL;
    fonction(&mon_tab);
    if (mon_tab != NULL)
    {
        /* Traitements sur mon_tab */
    }
    else
    {
        /* Message: erreur d'allocation */
    }
 
    return 0;
}

Ici, pp_tab est initialisé avec l'adresse de mon_tab. Par la suite, un tableau est créé dynamiquement au sein de la fonction, est son adresse est copiée à l'adresse pointée par pp_tab, c'est-à-dire dans la variable mon_tab. Ainsi, mon_tab pointe maintenant sur le tableau alloué dynamiquement par fonction().

C'est le même mécanisme pour un tableau à trois dimensions. On peut faire:

Code :

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

int ***array3d_new(int a, int b, int c);

mais comme je réserve la valeur de retour pour les codes d'erreur, il me faut retourner le tableau via les arguments de la fonction, et pour cela, je dois ajouter un niveau d'indirection supplémentaire. Il vien donc:

Code :

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

erreur_e array3d_new(int ****tab, int a, int b, int c);

2) Pour un type complexe déclaré de la manière suivante:

Code :

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

1
2
3
4
typedef struct MComplex_ {
    double real;
    double imag;
} MComplex_s;

C'est exactement la même chose, sauf que tu changes toutes les déclarations de tableaux de int en tableaux de MComplex_s. Tu peux t'inspirer du lien que je t'ai passé et qui propose 5 manières de créer un tableau dynamique à 2 dimensions (dont seules les 3 premières sont utilisables si tu as besoin que la taille des 2 dimensions soient modifiables).

Bonne chance

Thierry

**azez** · 19/04/2007, 12h17

merci de votre aide Thierry et Médinoc; j'ai compris pour quoi 4 indirections aulieu de 3.

@ Thierry : j'ai un problème utilisant ton code :

j'ai lancer l'exucutable avec a = 2, b = 3, c = 4 le resultat est bon un tableau de 24 éléments ;

j'ai lancer l'exucutable avec a = 2, b = 2, c = 2 et surprise !! ça me donne le méme resultat précédent c-à-d tableau de 24 éléments aulieu de 8.

j'ai lancer l'exucutable avec a = 0, b = 0, c = 0 normalement ça me donne ARRAY3D_ERR_SIZE et ben non ça a donné les mémes 24 éléments.

alors où est le problème ? est ce qu'il y'a une mauvaise libération de mémoire où quoi ?

**Thierry Chappuis** · 19/04/2007, 16h07

Envoyé par azez

merci de votre aide Thierry et Médinoc; j'ai compris pour quoi 4 indirections aulieu de 3.

@ Thierry : j'ai un problème utilisant ton code :

j'ai lancer l'exucutable avec a = 2, b = 3, c = 4 le resultat est bon un tableau de 24 éléments ;

j'ai lancer l'exucutable avec a = 2, b = 2, c = 2 et surprise !! ça me donne le méme resultat précédent c-à-d tableau de 24 éléments aulieu de 8.

j'ai lancer l'exucutable avec a = 0, b = 0, c = 0 normalement ça me donne ARRAY3D_ERR_SIZE et ben non ça a donné les mémes 24 éléments.

alors où est le problème ? est ce qu'il y'a une mauvaise libération de mémoire où quoi ?

Chez moi, cela fonctionne normallement. Es-tu certain d'avoir re-compilé après chaque modification?

Thierry

Fonction Deallocate tableau 4D

C

Discussions similaires

Partager

Partager