Fonction Deallocate tableau 4D

Version imprimable

Voir 40 message(s) de cette discussion en une page

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:

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:

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.

17/04/2007, 20h13
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:

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);
17/04/2007, 21h50
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...

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:

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.

Citation:

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:

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

18/04/2007, 01h02
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:

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
18/04/2007, 09h35
Médinoc

Citation:

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...
18/04/2007, 10h13
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
18/04/2007, 10h22
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...
18/04/2007, 11h23
Thierry Chappuis
Citation:
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
18/04/2007, 12h55
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 ?
18/04/2007, 17h28
Thierry Chappuis

Citation:

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
18/04/2007, 17h43
Médinoc

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...
18/04/2007, 20h22
azez

salut,

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

Citation:

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

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:

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

19/04/2007, 09h28
azez

ok maintenant je vois bien le principe merci :king:

deux questions stp :

1-

Code:

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?.
19/04/2007, 09h39
Médinoc
- 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)...

Citation:

Envoyé par azez

ok maintenant je vois bien le principe merci :king:

deux questions stp :

1-

Code:

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:

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:

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:

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:

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:

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

19/04/2007, 11h17
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 ?
19/04/2007, 15h07
Thierry Chappuis

Citation:

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

Voir 40 message(s) de cette discussion en une page