valeurs de tableaux multidimensionnels

Version imprimable

Bonjour,

Voici la création de deux tableaux multidimensionnels
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 // Three-dimensional array. int[, ,] array3D = new int[,,] { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 7, 8, 9 }, { 10, 11, 12 } } }; // The same array with dimensions specified. int[, ,] array3Da = new int[2, 2, 3] { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 7, 8, 9 }, { 10, 11, 12 } } }; // Accessing array elements. MessageBox.Show("la valeur du tableau 3DA est " + array3Da[1, 0, 1]); MessageBox.Show("la valeur du tableau 3D est " + array3D[1, 1, 2]);
Lorsque j'exécute ce code , voici les messages affichés au niveau des boites de dialogue:
"la valeur du tableau 3DA est 8"
"la valeur du tableau 3D est 12".

Pouvez-vous m'aider à retrouver comment s'y est pris le compilateur pour trouver ces valeurs.
Si avec un tableau à deux dimensions je m'y retrouve, avec un tableau à 3 dimensions, je m'y retrouve moins .

Merci beaucoup à vous.

Bien cordialement.

new_wave

Voilà une décomposition des éléments de ton tableau qui devrait clarifier un peu les choses :

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
int[, ,] array3D = new int[,,]
{
    // [0,*,*]
    {
        // [0,0,*]
        {
            // [0,0,0]
            1,
            // [0,0,1]
            2,
            // [0,0,2]
            3
        },
        // [0,1,*]
        {
            // [0,1,0]
            4,
            // [0,1,1]
            5,
            // [0,1,2]
            6
        }
    },
    // [1,*,*] 
    {
        // [1,0,*]
        {
            // [1,0,0]
            7,
            // [1,0,1]
            8,
            // [1,0,2]
            9
        },
        // [1,1,*]
        {
            // [1,1,0]
            10,
            // [1,1,1]
            11,
            // [1,1,2]
            12
        }
    }
};

29/07/2014, 14h16
new_wave

tableaux multidimensionnels

Merci beaucoup à toi.

Je vais y réfléchir et reviens vers toi aussitôt.

Cordialement.

new_wave
29/10/2014, 14h32
new_wave

tableaux multi dimensionnels
Bonjour et merci à toi de ta réponse.
J'ai bien compris comment tu as procédé mais pourquoi faut-il que lorsque tu considères cette ligne
Code:

1 2 3 4 5 6 7 8 9 10 11 12 // [0,*,*] { // [0,0,*] { // [0,0,0] 1, // [0,0,1] 2, // [0,0,2] 3 },
tu comprends que la valeur maximale de * est 2?
pourquoi ne pas aller jusqu'à 3?

Te remerciant de ta réponse,

Bien cordialement.
new_wave

bonjour
Pour retrouver tes valeurs dans l'initialiseur il faut lire :

Les accolades les plus exterieures decrivent l'indice N°1
Les accolades interieures suivantes decrivent l'indice N°2
Les accolades interieures suivantes decrivent l'indice N°3
Etc...
exemple avec l'orde descriptif des accolades et les dimensions correspondantes:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 private void button2_Click(object sender, EventArgs e)
        {
            int[, ,] monArray = new int[2, 3, 4] {
                { // 1ere accolade  decrit Dim 1 
 
                    { 1, 2, 3,4   }, // 1ere accolade decrit Dim 2 
                    { 5, 6, 7,8   }, // 2eme accolade idem...=>Afficher elem 3 soit 6(indice 1)
                    { 9, 10, 11,12}  // 3eme accolade idem
                } ,
                { // 2eme accolade  decrit Dim 1
 
                    { 10, 20, 30 ,40  }, // 1ere accolade decrit Dim 2 
                    { 50, 60, 70 ,80  }, // 2eme accolade idem 
                    { 90, 100, 110,120}  // 3eme accolade idem ...=>Afficher elem 3 soit 110(inice 2)
                } 
            }; 
         // Accessing array elements.
            MessageBox.Show(" valeur de l'element 6   est " + monArray[0, 1, 1]);
            MessageBox.Show(" valeur de l'element 110 est " + monArray[1, 2, 2]);
        }

bon code...

30/10/2014, 17h40
StringBuilder

Bonjour,

Juste comme ça en passant.

Si les tableaux multi-dimensionnels sont séduisants (en toute logique, en appliquant juste un offset à chaque indice, on est capable de récupérer chaque élément de manière très véloce en mémoire, il y a quelques années, j'ai été obligé d'admettre que des arrays de arrays sont beaucoup plus rapide que des arrays multi-dimensionnels (ce qui est en soit totalement délirant, j'ai toujours pas réussi à comprendre comment c'était possible).

Bref, pour des besoins de formation, très bien les tableaux multi-dimensionnels, mais dans la vie de tous les jours, préférer les tableaux de tableaux.

D'ailleurs, la déclaration inline d'un tel tableau (cf. les codes ci-dessus) passe bien par du array de array.

En effet, un int[2,2,2] devrait se déclarer { 1, 2, 3, 4, 5, 6, 7, 8 } et non pas {{{1, 2},{3, 4}},{{5, 6}, {7, 8}}} qui est en réalité un int[int[int[]]]

Donc préférer un :

int[int[int[]]] qu'un int[,,]

Accessoirement, les tableaux de tableau, ça permet aussi de gagner de la place mémoire si les tableaux ne font pas tous les mêmes tailles. Attention cependant à pas avoir de décalage dans ce cas (l'origine sera toujours à 0 en C#)
03/11/2014, 15h56
new_wave

Bonjour et merci de toutes ces infos.

J'ai bien compris à présent .
Je retiens l'utilité de tableaux de tableaux plutôt que celle de tableaux à plusieurs dimensions.
Je considère la question comme résolue.

Bien cordialement.

new_wave