Discussion :

[CactO_o's]

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 :

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

Merci à tous

[3DArchi]

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

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 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! */
     }
}

[ArnaudDev]

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

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

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

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

[CactO_o's]

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 :

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

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 :

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

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 :

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

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

[Scorpi0]

Un conseil : utilise la version dynamique !!

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

[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

[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é.