Go - Tableaux multidimensionnels dans Go

Le langage de programmation Go permet des tableaux multidimensionnels. Voici la forme générale d'une déclaration de tableau multidimensionnel -

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

Par exemple, la déclaration suivante crée un 5 en trois dimensions. dix . 4 tableau d'entiers -

var threedim [5][10][4]int

Tableaux bidimensionnels

Un tableau à deux dimensions est la forme la plus simple d'un tableau multidimensionnel. Un tableau à deux dimensions est, par essence, une liste de tableaux à une dimension. Pour déclarer un tableau d'entiers bidimensionnel de taille [x, y], vous écririez quelque chose comme suit -

var arrayName [ x ][ y ] variable_type

variable_type peut être n'importe quel type de données Go valide et arrayNamesera un identifiant Go valide. Un tableau à deux dimensions peut être considéré comme un tableau qui aura x nombre de lignes et y nombre de colonnes. Un tableau à 2 dimensionsa, qui contient trois lignes et quatre colonnes peut être affiché comme ci-dessous -

Ainsi, chaque élément du tableau a est identifié par un nom d'élément de la forme a[ i ][ j ], où a est le nom du tableau, et i et j sont les indices qui identifient de manière unique chaque élément dans a.

Initialisation de tableaux bidimensionnels

Les tableaux multidimensionnels peuvent être initialisés en spécifiant des valeurs entre crochets pour chaque ligne. Voici un tableau avec 3 lignes et chaque ligne a 4 colonnes.

a = [3][4]int{  
   {0, 1, 2, 3} ,   /*  initializers for row indexed by 0 */
   {4, 5, 6, 7} ,   /*  initializers for row indexed by 1 */
   {8, 9, 10, 11}   /*  initializers for row indexed by 2 */
}

Accès aux éléments de matrice bidimensionnelle

Un élément d'un tableau à deux dimensions est accessible en utilisant les indices, c'est-à-dire l'index de ligne et l'index de colonne du tableau. Par exemple -

int val = a[2][3]

L'instruction ci-dessus prendra le 4ème élément de la 3ème ligne du tableau. Vous pouvez le vérifier dans le diagramme ci-dessus. Vérifions ci-dessous le programme où nous avons utilisé une boucle imbriquée pour gérer un tableau à deux dimensions -

package main

import "fmt"

func main() {
   /* an array with 5 rows and 2 columns*/
   var a = [5][2]int{ {0,0}, {1,2}, {2,4}, {3,6},{4,8}}
   var i, j int

   /* output each array element's value */
   for  i = 0; i < 5; i++ {
      for j = 0; j < 2; j++ {
         fmt.Printf("a[%d][%d] = %d\n", i,j, a[i][j] )
      }
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

a[0][0]: 0
a[0][1]: 0
a[1][0]: 1
a[1][1]: 2
a[2][0]: 2
a[2][1]: 4
a[3][0]: 3
a[3][1]: 6
a[4][0]: 4
a[4][1]: 8

Comme expliqué ci-dessus, vous pouvez avoir des tableaux avec n'importe quel nombre de dimensions, bien qu'il soit probable que la plupart des tableaux que vous créez soient d'une ou deux dimensions.