Discussion :

[mecaplus]

Bonjour,

Je cherche à allouer de la mémoire en utilisant soit malloc ou calloc. J'ai lu beaucoup de choses sur la toile mais c'est des exemples pour des tableaux à une ou deux dimensions .

exemple pour un tableau 1 dimension :

Code :

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

1
2
3
 
int* tab = NULL;
    tab = malloc(largeur * sizeof(int));

et pour un tableau a 2 dimensions :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int ** tab = malloc(nblignes*sizeof(int));
for(int i = 0, i < nblignes; ++i)
{
    tab[i] = malloc(nbcolonnes*sizeof(int));
}
//et tab[x][y] pour acces aux elements
 
//libération de la memoire
for(int i = 0, i < nblignes; ++i)
{
    free(tab[i]);
}
free(tab);

Il y a bien évidement des versions sans les crochets []...

Cependant je n'arrive pas à l'adapter au cas d'un tableau de plus de 3 dimensions, précisément 4 du style

Code :

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

int tab[i][j][k][l]

Comment allouer de la mémoire dans ce cas?
Pour l'accès aux différents éléments du tableau je suppose que le principe est le même qu'un tableau normal multidimensionnel.

D'avance merci pour vos éclaircissements.

[souviron34]

Cependant je n'arrive pas à l'adapter au cas d'un tableau de plus de 3 dimensions, précisément 4 du style

Qu'est-ce qui te poses problème ?


C'est exactement le même principe..


Tu auras comme base des ***** et non des **

[diogene]

Allouer un tableau 4D int [i][j][k][l] :
1- Allouer un tableau de i pointeurs int***
2- Pour chaque pointeur, allouer 1 tableau 3D int [j][k][l]

Allouer un tableau 3D int [j][k][l] :
1- allouer un tableau de j pointeurs int**
2- pour chaque pointeur, allouer 1 tableau 2D int [k][l]

Allouer un tableau 2D int [k][l] :
1- allouer un tableau de k pointeurs int*
2- pour chaque pointeur, allouer 1 tableau 1D int [l]

Allouer un tableau 1D int [l] :
1- allouer un tableau de l int

Remarque : Erreur ici

Code :

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

1
2
int ** tab = malloc(nblignes*sizeof(int *));
for(int i = 0, i < nblignes; ++i)....

[mecaplus]

Effectivement il y a une erreur

Remarque : Erreur ici

Code :

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

1
2
int ** tab = malloc(nblignes*sizeof(int *));
for(int i = 0, i < nblignes; ++i)....

Je vais donc faire ceci pour allouer dynamiquement de la memoire à un tableau 2d (ici nblignes=nbcolonnes)

Code :

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

1
2
3
4
5
6
7
8
 
int **tab;
tab=( int**) malloc (sizeof( int*)*nblignes);
 
	for (k=0; k<nbligness; k++)
	{
		tab[k]=( int*) malloc (sizeof(int)*nbcolonnes);
	}

après avoir testé que l'allocation a réussie,
je peux accéder aux données de la manière suivante :

Code :

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

1
2
 
tab[i][j]

comme pour un tableau normal.

ensuite une fois que je n'ai plus besoin d'utiliser ce tableau je libère la memoire allouer en faisant :

Code :

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

1
2
 
free(tab)

ça fonctionne donc de cette manière.
Maintenant je vais essayer de passer à une dimension supérieure à 2 et là c'est pas encore tout à fait claire.

Est ce que j'ai le droit de faire ceci pour un tableau 3d?

Code :

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

1
2
3
4
5
6
7
8
9
10
int ***Tableau= (int ***)calloc(dimension1, sizeof(int**));
	int i, j,k;
 
	for(i= 0; i < dimension1; i++)
	{
		tab3[i]= (int **)calloc(dimension2, sizeof(int*));
		for(j= 0; j < dimension2; j++)
			tab3[i][j]= (int *)calloc(dimension3, sizeof(int));
		}
	}

l'allocation dynamique réussie mais quand je souhaite accéder ou remplir tab3[i][j][k] comme le montre le code ci-dessous, ça plante (je suis sous windows, MinGW).

Code :

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

1
2
3
4
5
6
7
8
 
for (i=0;i<dimension1;i++){
     for (j=0;j<dimension1;j++){
         for (k=0;k<dimension1;k++){
             tab3[i][j][k]=10
         }
      }
}

Quelqu'un a une explication? Merci.

[Lucien63]

Tu n'utilise pas les mêmes dimensions que pour la création :

Code :

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

1
2
3
4
5
6
7
for (i=0;i<dimension1;i++){
     for (j=0;j<dimension1;j++){
         for (k=0;k<dimension1;k++){
             tab3[i][j][k]=10
         }
      }
}

[mecaplus]

Merci pour ta réponse.

Tu n'utilise pas les mêmes dimensions que pour la création :

Code :

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

1
2
3
4
5
6
7
for (i=0;i<dimension1;i++){
     for (j=0;j<dimension1;j++){
         for (k=0;k<dimension1;k++){
             tab3[i][j][k]=10
         }
      }
}

ok, juste une erreur lorsque j'ai recopié, mais le problème ne viendrait pas de là puisque dimension1=dimension2=dimension3.

Mais pour faire propre et pour l'adapter à un tableau quelconque 3d, je suis d'accord avec toi pour écrire :

Code :

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

1
2
3
4
5
6
7
for (i=0;i<dimension1;i++){
     for (j=0;j<dimension2;j++){
         for (k=0;k<dimension3;k++){
             tab3[i][j][k]=10
         }
      }
}

[Lucien63]

Poste un code qui compile !

C'est bourré d'erreurs élémentaire.
Des point virgule ou des accolades manquantes ....

[mecaplus]

Merci pour ta rigueur Lucienne63,

Voici un code qui compile et qui fonctionne chez moi :

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
 
  #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
 
 
 //int ***allouertab3d(int dim1,int dim2, int dim3);
 
 int main(int argc, char *argv[])
 
{
    int dim1=3;
	int dim2=3;
	int dim3=3;
	int i, j,k,n;
	int ***tab3d=(int ***)calloc(dim1, sizeof(int**));
	FILE *fichier;
 
 
 
	for(i= 0; i < dim1; i++)
	{
		tab3d[i]= (int **)calloc(dim2, sizeof(int*));
		for(j= 0; j < dim2; j++){
			tab3d[i][j]= (int *)calloc(dim3, sizeof(int));
		}
	}
 
    if(tab3d==NULL){
		printf("Allocation impossible \n");
		exit(-1);
	}
	else{
	    /* Initialisation */
	    for (i=0;i<dim1;i++){
		   for(j=0;j<dim2;j++){
				for(k=0;k<dim3;k++){
				  tab3d[i][j][k]=10;
				}
			}
		}
 
	    /* Affichage et écriture dans un fichier */
		fichier=fopen("fichier.txt","w");
 
			if(fichier!=NULL){
				n=0;
				for (i=0;i<dim1;i++){
					for(j=0;j<dim2;j++){
						for(k=0;k<dim3;k++){
							printf("n=%d %d\n",n,tab3d[i][j][k]);
							fprintf(fichier,"%d %d\n",n,tab3d[i][j][k]);
							n++;
						}
					}
 
				}
				fclose(fichier);
			}else{printf("Louverture du fichier a echouer \n");exit(-2);}
 
 
	   free(tab3d);
 
	}
 
 
  return EXIT_SUCCESS;
 
} /* Fin du programme principal */

c'est donc un tableau de taille (dim1*dim2*dim3), voici le résultat affiché :

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
 
0 10
1 10
2 10
3 10
4 10
5 10
6 10
7 10
8 10
9 10
10 10
11 10
12 10
13 10
14 10
15 10
16 10
17 10
18 10
19 10
20 10
21 10
22 10
23 10
24 10
25 10
26 10

Je souhaite un int tab3d[dim1][dim2][dim3];

Encore merci.

[Lucien63]

Je souhaite un int tab3d[dim1][dim2][dim3];

Et bien, C'est bien ce que tu obtients !

C'est l'affichage qui ne te convients pas ?

[mecaplus]

Merci, oui effectivement l'affichage n'est pas très parlant. Un affichage correspondant à la structure "visuelle" du tableau serait préférable, c'est à dire tab3d[dim1][dim2][dim3]

même si je sais que le stockage en mémoire est différent.

Maintenant, comment passer au tableau 4d?

[mecaplus]

Ok j'ai compris le principe, voici le code pour allouer dynamiquement un tableau de 4 dimensions.

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
 
 #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
 
 
 int main(int argc, char *argv[])
 
{
    int dim1=2;
	int dim2=2;
	int dim3=2;
	int dim4=2;
	int i, j,k,n,l;
	int ****tab4d;
	FILE *fichier;
 
 
    tab4d=(int ****)calloc(dim1, sizeof(int***));
 
	for(i= 0; i < dim1; i++)
	{
		tab4d[i]= (int ***)calloc(dim2, sizeof(int**));
		for(j= 0; j < dim2; j++){
			 tab4d[i][j]= (int **)calloc(dim3, sizeof(int*));
			  for(k= 0; k < dim3; k++){
				  tab4d[i][j][k]= (int *)calloc(dim4, sizeof(int));
		    }
	   }
	}
 
    if(tab4d==NULL){
		printf("Allocation impossible \n");
		exit(-1);
	}
	else{
	    /* Initialisation */
	    for (i=0;i<dim1;i++){
		   for(j=0;j<dim2;j++){
				for(k=0;k<dim3;k++){
					for(l=0;l<dim4;l++){
						tab4d[i][j][k][l]=10;
				  }
				}
			}
		}
 
	    /* Affichage et écriture dans un fichier */
		fichier=fopen("fichier.txt","w");
 
			if(fichier!=NULL){
				n=0;
				for (i=0;i<dim1;i++){
					for(j=0;j<dim2;j++){
						for(k=0;k<dim3;k++){
								for(l=0;l<dim4;l++){
									printf("n=%d %d\n",n,tab4d[i][j][k][l]);
									fprintf(fichier,"%d %d\n",n,tab4d[i][j][k][l]);
									n++;
								}
						}
					}
 
				}
				fclose(fichier);
			}else{printf("Louverture du fichier a echouer \n");exit(-2);}
 
       /* Liberation de la memoire allouee au tab4d */
 
		for (i=0; i<dim1; i++){
			for (j=0; j<dim2; j++){
				for (k=0; k<dim3; k++){
					free(tab4d[i][j][k]);
				}
					free(tab4d[i][j]);
			}
			free(tab4d[i]);
		}     
		free(tab4d);
 
 
	}
 
 
  return EXIT_SUCCESS;
 
} /* Fin du programme principal */

résultat :

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
 
0 10
1 10
2 10
3 10
4 10
5 10
6 10
7 10
8 10
9 10
10 10
11 10
12 10
13 10
14 10
15 10

La libération de la mémoire allouée dynamiquement doit-elle forcément se faire par l'intermédiaire d'une boucle comme pour l'allocation dynamique?
Il n'est pas possible de faire simplement :

Code :

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

free(tab4d) /*?*/

[Lucien63]

La libération de la mémoire allouée dynamiquement doit-elle forcément se faire par l'intermédiaire d'une boucle comme pour l'allocation dynamique?

Tout à fait !

[souviron34]

Il n'est pas possible de faire simplement :

Code :

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

free(tab4d) /*?*/

non..

ce free libérera uniquement :

Code :

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

    tab4d=(int ****)calloc(dim1, sizeof(int***));

, et il te restera toutes les autres allocations, dont tu ne pourras plus atteindre les pointeurs puisque tu auras libéré la base pour les atteindre..

Donc fuite de mémoire...


Principe de base : à chaque alloc un free

[lilington]

hey oui c'est la toute la beaute du C, faut liberer chaque pointeur. sinon si ca t'enerve de trimbaler plein de boucle tu peux les mettres dans une fonction comme ca tu n'auras qu'a l'appeller chaque fois que tu en aura besoin:

Code :

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

1
2
3
4
int *****tbl; ...
...
...
releaseIT(&tbl,dimension1)

Code :

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

1
2
3
4
5
6
void releaseIT(int *****ptr,int dim)
{
   int ****p=*ptr;
   //et en suite tu fait les boucles pour liberer p
   free(p);
}

bien sur si tes dimensions sont differentes tu devrais penser a trouver un moyen de passer les 4 dimensions a la fonction

[mecaplus]

Merci à tous pour vos contributions.

J'ai écris ce petit programme pour allouer dynamiquement de la mémoire (cas d'un tableau 4d), libérer de la mémoire lorsque je n'ai plus besoin du tableau. Après l'allocation, je remplis le tableau et je l'affichage. J'ai pour cela :

• une fonction qui alloue la mémoire et la libère (grâce à un paramètre option),
• une fonction qui remplit le tableau 4D et
• une fonction qui affiche le tableau 4D

Pas de problème à la compilation et le programme plante à l'exécution après l'allocation.

Où est ce que j'ai pu commettre une erreur, dans le passage des paramètres aux différentes fonctions (remplissage, affichage) où c'est le fait d'avoir réuni au sein de la fonction allocationDynamique l'allocation et la libération de la mémoire?

Voici le code associé :

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
 
 
 #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
 
 void AllocationDynamique(int ****tab4d, int dim1, int dim2, int dim3, int dim4, int option);
 void Remplissage(int ****tab4d, int dim1, int dim2, int dim3, int dim4);
 void Affichage(int ****tab4d, int dim1, int dim2, int dim3, int dim4);
 
int main(int argc, char *argv[])
{
 
int ****tab=NULL;
 
 
int dimension1;
int dimension2;
int dimension3;
int dimension4;
 
        dimension1=2;
		dimension2=2;
		dimension3=2;
		dimension4=2;
 
/* Option 1 : allocation
   Option 2 : liberation
 */
 
		/* Allocation dynamique */
		AllocationDynamique(tab,dimension1, dimension2,dimension3,dimension4,1);
		/* Remplissage */
		Remplissage(tab,dimension1, dimension2,dimension3,dimension4);
		/* Affichage */
		Affichage(tab,dimension1, dimension2,dimension3,dimension4);
 
		/* Liberation */
		AllocationDynamique(tab,dimension1, dimension2,dimension3,dimension4,2);
 
 
return EXIT_SUCCESS;
 
} /* Fin du programme principal */
 
 
 
void AllocationDynamique(int ****tab4d, int dim1, int dim2, int dim3, int dim4, int option)
 
{
 
		int i, j,k;
 
		switch(option) 
		{
			case 1 : /* Allocation tableau 4d */
 
				tab4d=(int ****)calloc(dim1, sizeof(int***));
 
				for(i= 0; i < dim1; i++)
				{
					tab4d[i]= (int ***)calloc(dim2, sizeof(int**));
						for(j= 0; j < dim2; j++){
							tab4d[i][j]= (int **)calloc(dim3, sizeof(int*));
								for(k= 0; k < dim3; k++){
									tab4d[i][j][k]= (int *)calloc(dim4, sizeof(int));
								}
						}
				}
 
				if(tab4d==NULL){
					printf("Allocation impossible \n");
					exit(-1);
				}
 
 
				break;
 
			case 2 : /* Liberation memoire allouee dynamiquement */
 
			//if(tab4d!=NULL){
				for (i=0; i<dim1; i++){
					for (j=0; j<dim2; j++){
						for (k=0; k<dim3; k++){
							free(tab4d[i][j][k]);
						}
						free(tab4d[i][j]);
					}
					free(tab4d[i]);
				}     
				free(tab4d);
			/*}else{
				printf("Pas d'allocation preable \n");
				exit(-1);
			}
			*/
			break;
 
			default :
			printf("Cas non prevu \n");
			exit(0);
			break;
 
		}/* Fin switch(option) */
 
} /* Fin programme allocation dynamique tab4d*/
 
 
 
 
void Remplissage(int ****tab4d, int dim1, int dim2, int dim3, int dim4)
{
int i,j,k,l;
 
				for (i=0;i<dim1;i++){
					for(j=0;j<dim2;j++){
						for(k=0;k<dim3;k++){
								for(l=0;l<dim4;l++){
								    tab4d[i][j][k][l]=10;
								}
						}
					}
 
				}
 
} /* Fin programme remplissage */
 
 
void Affichage(int ****tab4d, int dim1, int dim2, int dim3, int dim4)
{
int i,j,k,l,n;
			n=0;
				for (i=0;i<dim1;i++){
					for(j=0;j<dim2;j++){
						for(k=0;k<dim3;k++){
								for(l=0;l<dim4;l++){
									printf("n=%d %d\n",n,tab4d[i][j][k][l]);
									n++;
								}
						}
					}
 
				}
 
} /* Fin programma affichage */

[Lucien63]

Ton pointeur tab ne contient pas l'adresse du tableau à la sortie de la fonction d'allocation.
Toujours penser que les paramètres de fonction sont passés par copie.

[mecaplus]

Merci. ça l'air compliquer le 4d pour l'instant.
Je vais y aller tout doucement, voici le code pour un tableau 3d. Celui-ci fonctionne chez moi.

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
 
 
 #include <stdio.h>
 #include <math.h>
 #include <stdlib.h>
 
 int ***allouertableau3d(int dim1, int dim2, int dim3);
 int ***remplirtableau3d(int dim1, int dim2, int dim3);
 void liberertableau3d(int ***tableau);
 void affichertableau3d(int ***tableau, int dim1, int dim2, int dim3);
 
 
 
int main(int argc, char *argv[])
{
int i,j,k;
 
int ***tab3d;
 
int dimension1;
int dimension2;
int dimension3;
 
        dimension1=2;
		dimension2=2;
		dimension3=2;
 
 
		tab3d=allouertableau3d(dimension1, dimension2, dimension3);
		affichertableau3d(tab3d,dimension1, dimension2, dimension3);
		liberertableau3d(tab3d);
		tab3d=remplirtableau3d(dimension1, dimension2, dimension3);
 
				for(i=0;i<dimension1;i++)
				{
				  for(j=0;j<dimension2;j++){
				     for(k=0;k<dimension3;k++){
					    printf("%d\n",tab3d[i][j][k]);
 
					 }
				}
				}
 
return EXIT_SUCCESS;
 
} /* Fin du programme principal */
 
 
int ***remplirtableau3d(int dim1, int dim2, int dim3)
{
int i,j,k;
 
int ***tableau3d;
 
			tableau3d=allouertableau3d(dim1,dim2,dim3);
 
				for (i=0;i<dim1;i++){
					for(j=0;j<dim3;j++){
						for(k=0;k<dim2;k++){
								    tableau3d[i][j][k]=10;
						}
					}
 
				}
 
				return tableau3d;
 
} /* Fin programme remplissage */
 
 
int ***allouertableau3d(int dim1, int dim2, int dim3)
{
int ***tableau;
int i,j;
tableau=malloc(dim1*sizeof(int **));
tableau[0]=malloc(dim1*dim2*sizeof(int *));
tableau[0][0]=malloc(dim1*dim2*dim3*sizeof(int));
 
for(i=0;i<dim1;i++)
{
	tableau[i]=tableau[0]+i*dim2;
	for(j=0;j<dim2;j++)
		tableau[i][j]=tableau[0][0]+i*dim2*dim3+j*dim3;
	}
	return tableau;
}
 
void liberertableau3d(int ***tableau)
{
 
free(tableau[0][0]);
free(tableau[0]);
free(tableau);
}
 
 
void affichertableau3d(int ***tableau, int dim1, int dim2, int dim3)
{
int i,j,k;
for (i=0;i<dim1;i++)
{
  for(j=0;j<dim3;j++)
  {
   for(k=0;k<dim2;k++){
 
     fprintf(stdout,"tableau[%d][%d][%d]=%d\n",i,j,k,tableau[i][j][k]);
   }
   }
   }
}

Je continu à chercher pour le tableau 4d. Encore merci pour votre aide.

[Lucien63]

Code :

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

 ça l'air compliquer le 4d pour l'instant.

Tu n'étais pas loin pourtant.

L'allocation pour le 4D :
On passe un pointeur sur le pointeur du tableau 4D comme paramètre (Bon, ça fait une étoile de plus):
(j'ai simplifié la fonction d'allocation.)

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
void AllocationDynamique(int *****tab4d, int dim1, int dim2, int dim3, int dim4, int option)
{
 
 int i, j, k;
 
 *tab4d = calloc(dim1, sizeof(int***));
 
 for(i= 0; i < dim1; i++){
	(*tab4d)[i]= (int ***)calloc(dim2, sizeof(int**));
	for(j= 0; j < dim2; j++){
	  (*tab4d)[i][j]= (int **)calloc(dim3, sizeof(int*));
	  for(k= 0; k < dim3; k++){
		  (*tab4d)[i][j][k]= (int *)calloc(dim4, sizeof(int));
      }
    }
  }
}

Puis on passe l'adresse du pointeur sur le tableau 4D pour l'appel de la fonction :

Code :

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

AllocationDynamique(&tab, dimension1, dimension2,dimension3,dimension4);

Par contre avec ton 3D tu es en train de te compliquer la vie. L'allocation de ton 3D est à revoir.
Par contre de retourner le pointeur du tableau comme tu l'as fait est aussi une solution.

[mecaplus]

Ces deux fonctions sont équivalents?

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
 
void AllocationDynamique(int *****tab4d, int dim1, int dim2, int dim3, int dim4)
{
int i,j,k;
 
tab4d=(int ****)calloc(dim1, sizeof(int***));
 
	for(i= 0; i < dim1; i++)
	{
		tab4d[i]= (int ***)calloc(dim2, sizeof(int**));
		for(j= 0; j < dim2; j++){
			 tab4d[i][j]= (int **)calloc(dim3, sizeof(int*));
			  for(k= 0; k < dim3; k++){
				  tab4d[i][j][k]= (int *)calloc(dim4, sizeof(int));
		    }
	   }
	}
}

ou

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
 
 
void AllocationDynamique(int *****tab4d, int dim1, int dim2, int dim3, int dim4)
{
 
 int i, j, k;
 
 *tab4d = calloc(dim1, sizeof(int***));
 
 for(i= 0; i < dim1; i++){
	(*tab4d)[i]= (int ***)calloc(dim2, sizeof(int**));
	for(j= 0; j < dim2; j++){
	  (*tab4d)[i][j]= (int **)calloc(dim3, sizeof(int*));
	  for(k= 0; k < dim3; k++){
		  (*tab4d)[i][j][k]= (int *)calloc(dim4, sizeof(int));
      }
    }
  }
}

Je vais revoir l'allocation 3d et tester ta solution. C'est souvent à la libération et à l'accès aux variables contenant dans les cases du tableau que ça pose problème (passage des paramètres).

Pour l'allocation ça plutôt l'air de fonctionner. Je te tiens au courant.

Quelle est la forme la mieux adapté (optimisée) entre retourner le pointeur du tableau et la solution ci-dessus?

Je pense que je vais partir sur des fonctions séparées : allocation, libération de la mémoire.

Merci pour ton aide.

[Lucien63]

Ces deux bouts codes sont équivalents?

Non pas du tout !

tab4d n'est pas la même chose que *tab4d
Le deuxième utilise l'opérateur de déréférencement de pointeur.