Discussion :

[ford_escort]

Bonjour,
nouveau sur le forum, j espere que ma question n a pas ete posee precedement.
Voila le probleme qui se pose :
Je souhaiterai pouvoir faire une allocation dynamique d un tenseur a 4 indices, c est a dire qq chose qui aurait cette tete la : tenseur[indice1][indice2][indice3][indice4]
Est ce que qq un aurait deja eu le meme probleme?
Merci

Ford_escort

[programan]

Merci de consulter la !

http://c.developpez.com/faq/c/?page=...bleau_2D_alloc

Il n'y a plus qu'à appliquer le même principe pour 4 dimensions.

[Trap D]

Attention tout de même à ce qui est é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
/* METHODE 1 */
char **tab;
 
/* Allocation de la 1er dimension */
tab = malloc ( sizeof(*tab)  *  taille);
 
// il faut toujours vérifier le retour de malloc
if (tab == NULL)
{
  fprintf(stderr, "Pb alloc mémoire 1\n");
  // peut-être une sortie
}
 
/* Allocation des tableaux */
for (i=0; i<taille; i++) {
    if ((tab[i] = malloc ( sizeof(**tab) * taille2)) == NULL)
   {
        fprintf(stderr, "Pb alloc mémoire 2\n");
        // il faut désallouer tous les indices déjà alloués
       // puis désallouer tab
       // peut-être enfin sortir
 
   }
}

[programan]

Je pensais plutôt à la deuxième méthode qui est, il me semble, la seule utilisable pour un tableau de plus de 2 dimensions. Il faut juste être rigoureux (comme d'habitude en programmation remarque ) avec les indices et les tailles au niveau de la formule à appliquer pour retrouver la bonne valeur de l'indice.

[diogene]

appliquer le même principe pour 4 dimensions

Ce qui peut devenir lourd. Si les dimensions sont des constantes connues à la compilation, on peut allouer directement et passer sans problèmes le tableau en paramètre des fonctions
exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
typedef   float T4 [Q][R][S];
  T4 * Tab = malloc( P*sizeof(T4));
....
Tab[1][2][0][3] = 12345;
....
 fonc(Tab);
....
 fonc (T4 * t)
 {
   t[0][1][2][3] = 54321
}

à condition que Q, R,S soient des constantes connues à la compilation . pour P, ce n'est pas nécessaire

[ford_escort]

ce que j ai fait ressemble a la premiere methode, mais je ne peux pas allouer des tableaux d entier plus grand que 100*100*100*100.

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
int ****
itensor4(long index1, long index2, long index3,long index4)
	/*allocate a 4tensor*/
{
 int i,j,k;
 int ****t;
 
  if((t=(int ****) malloc((size_t)(index1*sizeof(int**)))) == NULL){
    perror("malloc");
    return NULL;
  }
 
  if((t[0]=(int ***) malloc((size_t)((index1*index2)*sizeof(int*)))) == NULL){
    perror("malloc");
    return NULL;
  }
 
  if((t[0][0]=(int **) malloc((size_t)((index1*index2*index3)*sizeof(int)))) == NULL){
    perror("malloc");
    return NULL;
  }
 
  if((t[0][0][0]=(int *) malloc((size_t)((index1*index2*index3*index4)*sizeof(int)))) == NULL){
    perror("malloc");
    return NULL;
  }
 
for(j=1;j<index3;j++)
    t[0][0][j]=t[0][0][j-1]+index4;
 
for(j=1;j<index2;j++)
    t[0][j]=t[0][j-1]+index3;
 
for(i=1;i<index1;i++)
{
	t[i]=t[i-1]+index2;
	t[i][0]=t[i-1][0]+index2*index3;
	t[i][0][0]=t[i-1][0][0]+index2*index3*index4;
 
	for(j=1;j<index2;j++)
	{
		t[i][j]=t[i][j-1]+index3;
		for(k=1;k<index3;k++)
			t[i][j][k]=t[i][j][k-1]+index4;
  	}
 }
 return t;  
}

En plus mes dimensions n ont pas toutes les memes valeurs, donc apparement je dois suivre la premiere methode.

[programan]

Ce qui peut devenir lourd. Si les dimensions sont des constantes connues à la compilation, on peut allouer directement et passer sans problèmes le tableau en paramètre des fonctions

Par constantes, tu veux bien dire des constantes symboliques, définies par un #define? Il me semble que dans ce cas, la question de l'allocation dynamique ne se pose même plus... Mais si les dimensions sont variables, on doit passer par l'allocation dynamique.

int ****t;

Ce qui peut devenir lourd.

Il me semble que l'utilisation d'un pointeur sur pointeur sur pointeur sur pointeur sur float ( ), c'est pas non plus ce qu'il y a de plus digeste, mais bon...

Je pense que la deuxième méthode est plus facile à gérer (en tout cas, on se plante moins lors de la rédaction des programmes), surtout si on prend la peine de rédiger une fonction qui fait le calcul pour nous, ce qui simplifie l'appel, du style:

Code :

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

1
2
3
4
5
6
 
float *tab;
tab = (float*)malloc(sizeof(*tab)*t1*t2*t3*t4);
 
tab[indice(i1,i2,i3,i4,t1,t2,t3,t4)] = 12.2;   
/* équivalent à tab[i1][i2][i3][i4] = 12.2 */

mais bon, c'est mon point de vue...

[DaZumba]

Les tableaux a plusieurs dimensions sont une plaie. Ils sont difficiles a allouer, difficiles a passer comme argument de fonction (cf. un sujet aujourd'hui), etc.
Personnellement, je prefere lineariser les tableaux, c'est a dire les considerer comme un tableau a une dimension, et jouer sur les indices pour "emuler" un tableau multidimensionnel.
Dans ton exemple, si on suppose quatre dimensions imax, jmax, kmax et lmax l'allocation est simplement:

Code :

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

1
2
3
4
5
6
7
8
 
double *tab;
 
tab = malloc(imax * jmax * kmax * lmax * sizeof *tab);
if(!tab)
{
   /* erreur */
}

On ne peut pas plus simple.
Maintenant, pour acceder a un element, au lieu de faire:

Code :

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

1
2
 
tab[i][j][k][l] = 0.0;

Tu fais

Code :

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

1
2
3
 
index = ((i * jmax + j ) * kmax + k) * lmax + l;
tab[index] = 0.0;

En bref, on deplace la complexite de la ou elle est difficile a gerer (allocation, passage en argument) a un endroit ou elle simple a gerer (calcul d'un indice).

[diogene]

Par constantes, tu veux bien dire des constantes symboliques, définies par un #define?

Oui

diogene a écrit:

Ce qui peut devenir lourd

.

Je pensais à la mise en oeuvre, pas à la syntaxe

Il me semble que dans ce cas, la question de l'allocation dynamique ne se pose même plus...

Si, tu peux avoir problème à allouer 400millions d'octets sur la pile. Mais si tes dimensions sont variables, il faut une allocation dynamique complète. Si de plus tu veux une écriture de forme t[][][][], utilise la solution de programan. La construction et la destruction ne sont pas tarte, mais on a rien sans rien.
DaZumba :

Les tableaux a plusieurs dimensions sont une plaie. Ils sont difficiles a allouer, difficiles a passer comme argument de fonction (cf. un sujet aujourd'hui), etc.

Ca c'est vrai et ta solution est facile à mettre en oeuvre, permet le passage aux fonctions avec un petit cast, mais laisse au programmeur le calcul de la position des éléments et ne permet la sacro-sainte écriture t[i][j][k][l]. On peut sans doute alors simplifier l'écriture à l'intérieur d'une fonction par un define approprié pour écrire qq chose du genre t(i,j,k,l) ce qui est assez lisible et compréhensible

[Emmanuel Delahaye]

Les tableaux a plusieurs dimensions sont une plaie. Ils sont difficiles a allouer, difficiles a passer comme argument de fonction (cf. un sujet aujourd'hui), etc.
Personnellement, je prefere lineariser les tableaux, c'est a dire les considerer comme un tableau a une dimension, et jouer sur les indices pour "emuler" un tableau multidimensionnel.

Je suis d'accord, et pour les accès, je fais une fonction qui retourne la donnée, ou l'adresse de la donnée si c'est une structure, en fonction des indices.

[programan]

Pour compléter, et puisque tout le monde semble à peu près d'accord, je donne le code de la fonction que j'utilise pour ceux que ça effraie un peu ( ):

Code :

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

1
2
3
4
5
6
7
8
9
 
unsigned long int indice(...)
{
  unsigned long int position;
 
  position = (i1*t2*t3*t4) + (i2*t3*t4) + (i3*t4) + i4;
 
  return(position);
}

C'est pas si terrible que ça, non?

A noter que la taille de la première dimension ne sert à rien, je l'ai mise dans l'appel que je donnais en exemple tout à l'heure par pur esthétisme... (non, je l'avoue, c'est plus par pure précipitation... )

[ford_escort]

C'est vraie que les constantes sont donnees par un #define
et que techniquement il n'y a pas de raison de d'allouer le tableau de facon dynamique.
Mais si je le fais de facon statique, je suis limite pour sa taille.
Il y a pas mal de reponses, je vais tester tout ca et voir jusqu'a quel taille je peux aller.
Merci

[diogene]

C'est vraie que les constantes sont donnees par un #define
et que techniquement il n'y a pas de raison de d'allouer le tableau de facon dynamique.
Mais si je le fais de facon statique, je suis limite pour sa taille

Alors, dans ce cas, tu peux avoir le beurre et l'argent du beurre : l'allocation dynamique simple + la notation tableau (voir mon premier message sur ce sujet)

[Emmanuel Delahaye]

C'est vraie que les constantes sont donnees par un #define
et que techniquement il n'y a pas de raison de d'allouer le tableau de facon dynamique.
Mais si je le fais de facon statique, je suis limite pour sa taille.
Il y a pas mal de reponses, je vais tester tout ca et voir jusqu'a quel taille je peux aller.
Merci

Il y a quand même des cas
- une taille importante
- on voudrait pouvoir modifier la taille
- le bloc de données change de thread...

[ford_escort]

Me revoila avec mon probleme d'allocation dynamique.
J'ai repris le code de programan. Ce qui donne :

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
 
#include <math.h> 
#include <stdio.h> 
#include <stdlib.h> 
#define a 4
#define b 100 
#define c 100 
#define d 100 
int indice3(int i1,int i2,int i3,int t1,int t2,int t3); 
int indice4(int i1,int i2,int i3,int i4,int t1,int t2,int t3,int t4); 
 
int main (void) 
{ 
int i,j,k,*n,*m; 
double *x,*y,*z; 
int n1x,n1y,n1z,nm; 
x=(double *)calloc(a,sizeof(double)); 
y=(double *)calloc(a,sizeof(double)); 
z=(double *)calloc(a,sizeof(double)); 
 
 x[0]=0.1;y[0]=0.1;z[0]=0.1; 
 x[1]=0.1;y[1]=0.2;z[1]=0.1; 
 x[2]=0.1;y[2]=0.1;z[2]=0.2; 
 x[3]=2.2;y[3]=2.2;z[3]=2.2; 
 
 n = ( int*)malloc(sizeof*(n)*a*b*c*d); 
 m = (int*)malloc(sizeof*(m)*b*c*d); 
             for (i=0;i<b;i++) 
                for (j=0;j<c;j++) 
                     for (k=0;k<d;k++) 
                          m[indice3(i,j,k,b,c,d)]=0; 
for (i=0;i<a;i++)  
        { 
                n1x=floor(x[i]); 
                n1y=floor(y[i]);
                n1z=floor(z[i]); 
 
                nm=m[indice3(n1x,n1y,n1z,b,c,d)]+1; 
                m[indice3(n1x,n1y,n1z,b,c,d)]=nm; 
                n[indice4(nm,n1x,n1y,n1z,a,b,c,d)]=i; 
 
        } 
 free(m); 
 free(n);  
 
return EXIT_SUCCESS; 
} 
 int indice3(int i1,int i2,int i3,int t1,int t2,int t3) 
{ 
   int position; 
  position = (i1*t2*t3) + (i2*t3) + i3; 
  return (position); 
} 
 
int indice4(int i1,int i2,int i3,int i4,int t1,int t2,int t3,int t4) 
{ 
int position; 
    position = (i1*t2*t3*t4) + (i2*t3*t4) + (i3*t4) + i4; 
  return(position); 
}

Le programme marche, mais j'ai toujours le meme probleme de memoire. Par exemple si je depasse 100*100*100*100 pour les indices, j'ai un message "segmentaion fault".Ce que je ne comprend pas car ca marche pour des indices plus petits.

[Emmanuel Delahaye]

Me revoila avec mon probleme d'allocation dynamique.
J'ai repris le code de programan. Ce qui donne :
<...>Le programme marche, mais j'ai toujours le meme probleme de memoire. Par exemple si je depasse 100*100*100*100 pour les indices, j'ai un message "segmentaion fault".Ce que je ne comprend pas car ca marche pour des indices plus petits.

Il faut vérifier le retour de *alloc(). En cas de d'erreur d'allocation, NULL est retourné.

D'autre part, il y a un problème de libération.

Code :

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

1
2
3
SYSALLOC Bloc 003D24C8 (32 bytes) calloc'ed at line 16 of 'main.c' not freed
SYSALLOC Bloc 003D24F0 (32 bytes) calloc'ed at line 17 of 'main.c' not freed
SYSALLOC Bloc 003D2518 (32 bytes) calloc'ed at line 18 of 'main.c' not freed

Ton code est plutôt étrange car il mélange les notions de tableaux linéaire à n dimensions calculées et les tableau à n dimensions simulés par des tableaux de pointeurs. C'est pas très clair...

Je ferais comme ça :

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
 
struct int3
{
    int *p;
    size_t x;
    size_t y;
    size_t z;
};
 
void int3_delete (struct int3 *this)
{
    if (this!=NULL)
    {
        if (this->p != NULL)
        {
            free(this->p), this->p=NULL;
        }
        free(this), this=NULL;
    }
}
 
struct int3 *int3_create (size_t x, size_t y, size_t z)
{
    struct int3* this = malloc (sizeof *this);
 
    if (this != NULL)
    {
        {
            static struct int3 const zero =
                {
                    0,0,0,0
                };
 
            /* clear all */
            *this=zero;
        }
 
        {
            /* tester le, risque de debordement... */
            unsigned long s = x * y;
 
            if (s < (size_t)-1)
            {
                s = s * z;
 
                if (s < (size_t)-1)
                {
                    size_t const size = s;
 
                    this->p = malloc (size * sizeof *this->p);
 
                    if (this->p != NULL)
                    {
                        size_t i;
 
                        for (i = 0; i < size; i++)
                        {
                            this->x = x;
                            this->y = y;
                            this->z = z;
                        }
                    }
                    else
                    {
                        int3_delete (this),this=NULL;
                    }
                }
                else
                {
                    int3_delete( this),this=NULL;
                }
            }
            else
            {
                int3_delete( this),this=NULL;
            }
        }
    }
    return this;
}
 
int *int3_adr (struct int3 *this , size_t i, size_t j, size_t k)
{
    int *p = NULL;
 
    if (i < this->x
            && j < this->y
            && k < this->z)
    {
        p = this->p + i * this->x + j * this->y + k;
    }
    return p;
}
 
 
int main (void)
{
    enum
    {
        X=100,
        Y=100,
        Z=100,
        dummy
    };
 
    struct int3 *tab = int3_create (X, Y, Z);
 
    if (tab != NULL)
    {
        size_t i;
        for (i = 0; i < X; i++)
        {
            size_t j;
            for (j = 0; j < Y; j++)
            {
                size_t k;
                for (k = 0; k < Z; k++)
                {
                    int *p = int3_adr (tab, i, j, k);
 
                    *p=0;
                }
            }
        }
 
        int3_delete(tab), tab=NULL;
    }
    return 0;
}

[Trap D]

Ton calcul d'indice devrait retourner un unsigned long plutôt qu'un int, tu renvoies sans doute parfois des valeurs négatives donc plante.