Comment créer un tableau à 3D par rapport à des variables

Version imprimable

Bonjour à tous !

J'ai un petit problème, il faut que j'envoie un tableau à 3 dimensions d'une fonction à une autre. Pour le moment rien de compliquer, le problème est que je ne connais qu'une seul solution sur les 3...

Pour bien comprendre un petit bout de code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 void fonction2(int tailleX, int tailleY, int tableau[][][3]) { /************************ utilisation du tableau ************************/ } void fonction1() { int tailleX = 0, tailleY = 0; /************** tailleX = ??; tailleY = ??; ***************/ int tableau[tailleX][tailleY][3] = {0}; fonction2(tailleX, tailleY, tableau); }
Comme vous le savez surement tous, ce code ne marche pas... Mais au moins sa me permet de vous faire comprendre...

Je ne sais vraiment pas comment faire. Aidez-moi :cry::cry:

Merci à tous

Bonjour,
A priori, la seule solution serait une allocation dynamique de ton tableau:

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 fonction2(int P_iTailleX, int P_iTailleY, int *P_piTableau)
{
    /************************
       utilisation du tableau
     ************************/
}
 
void fonction1()
{
    int L_iTailleX;
    int L_iTailleY;
    int *L_piTableau;

    L_iTailleX = 0;
    L_iTailleY = 0;
    
     /**************
       L_iTailleX = ??;
       L_iTailleY = ??;
     ***************/
     L_piTableau = malloc(sizeof(int)*L_iTailleX*L_iTailleX*3);
     if(L_piTableau){  
          fonction2(L_iTailleX, L_iTailleX, L_piTableau);
     }
     else{
          /* Erreur d'allocation! */
     }
}

mais moi j'aurai plus fait de l'allocation dynamique comme ceci:

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 fonction2(int tailleX, int tailleY, int tailleZ, int ***tableau)
{
    /************************
       utilisation du tableau
     ************************/
}
 
void fonction1()
{
    int tailleX = 1, tailleY = 1, tailleZ = 3;
    int ***tableau;
    int i,j;
 
    tableau = (int ***)malloc(tailleX *sizeof(int **));
    for (i=0;i<tailleX ;i++){
        tableau[i]=(int **)malloc(tailleY *sizeof(int *));
        for (j=0;j<tailleY ;j++){
            tableau[i][j] = (int *)malloc(tailleZ *sizeof(int));
        }
    }
 
    fonction2(tailleX, tailleY, tailleZ, tableau);
}

je pense aussi que le fait de mettre 0 en taille ça peut poser des problèmes

si tu veux rester en statique :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void fonction2(int tailleX, int tailleY, int tailleZ, int tableau[tailleZ ][tailleY][tailleZ])
{
    /************************
       utilisation du tableau
     ************************/
}
 
void fonction1()
{
    int tailleX = 1, tailleY = 1, tailleZ = 3;
    int tableau[tailleX ][tailleY ][tailleZ ];
 
    fonction2(tailleX, tailleY, tailleZ, tableau);
}

Merci beaucoup à vous, je vais avoir de quoi me pencher sur le sujet et travailler.

Je vais étudier vos code et je reviendrai Editer après pour donner des nouvelles
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void fonction(int tailleX, int tailleY, int tailleZ, int tableau[tailleZ ][tailleY][tailleZ]) { } void editerMap(char listeMap[], char sauvName[]) { int tailleX = 1, tailleY = 1, tailleZ = 3; int tableau[tailleX ][tailleY ][tailleZ ]; fonction(tailleX, tailleY, tailleZ, tableau); }
Il me semblait bien que la méthode du tableau statique ne fonctionne pas :
Code:

1 2 3 54 gestionMenuEditeurMap.cpp `tailleZ' was not declared in this scope 54 gestionMenuEditeurMap.cpp `tailleY' was not declared in this scope 54 gestionMenuEditeurMap.cpp `tailleX' was not declared in this scope
PS : la ligne 54 est la ligne

Code:

void fonction(int tailleX, int tailleY, int tailleZ, int tableau[tailleZ ][tailleY][tailleZ])

Un conseil : utilise la version dynamique !!

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void fonction2(int tailleX, int tailleY, int tailleZ, int ***tableau)
{
    /************************
       utilisation du tableau
     ************************/
}
 
void fonction1()
{
    int tailleX = 1, tailleY = 1, tailleZ = 3;
    int ***tableau;
    int i,j;
 
    tableau = (int ***)malloc(tailleX *sizeof(int **));
    for (i=0;i<tailleX ;i++){
        tableau[i]=(int **)malloc(tailleY *sizeof(int *));
        for (j=0;j<tailleY ;j++){
            tableau[i][j] = (int *)malloc(tailleZ *sizeof(int));
        }
    }
 
    fonction2(tailleX, tailleY, tailleZ, tableau);
}

14/07/2008, 17h56
CactO_o's

Ouais je vais surement utiliser cette version, mais je voulais quand même essaye les autres pour voir..

Par contre par rapport à cette façon dynamique, peut on changer la valeur de la taille d'une dimension du tableau au cour du programme ?
Si oui, comment ?

Merci
14/07/2008, 18h10
diogene

C'est possible.
On utilise la fonction realloc. Mais il faut faire attention parce que

- la réallocation peut échouer (comme l'allocation avec malloc et le code présenté ci-dessus devrait être complété pour tester cette possibilité)

- la réallocation peut changer l'adresse du bloc alloué.