Abordons maintenant les types de données composites. Les types de données composites permettent d'étendre les types de base. Ce sont des types de données qui s'assemblent, qui agrègent d'autres types de données.

La chaîne de caractères est un cas particulier car on pourrait être tenté de la considérer comme une agrégation de ses différents octets (agrégation des runes) mais ce n'est pas un type de données composite.

Nous allons parler plus généralement de tableaux. Ainsi, un tableau en général est un ensemble, une série d'éléments de longueur fixe et d'un type choisi.

Vous pouvez créer un tableau d'octets, un tableau d'entiers, un tableau de flottants, etc. Mais c'est une longueur fixe : tous les éléments sont identiques (même type) et de taille connue : C'est un concept clé des tableaux, ils sont de longueur fixe.

Le compilateur peut déterminer leur taille à la compilation : il sait combien d'espace en mémoire il doit leur allouer (données statiques).

D' une manière générale, ces types de données composites sont importants : dans tout type de programme complexe, vous devrez utiliser des types de données composites. Les types de bases sont nécessaires mais insuffisants, vous devrez regrouper et agréger les types de base dans une sorte de type de données composite.

Vous avez donc différents éléments d'un type choisit dans le tableau : si c'est un tableau d'entiers, vous avez un ensemble d'éléments de type entier.

Chaque élément est accessible en utilisant la notation indexée (indice entre crochets). Vous placez l'index juste au milieu des crochets. Nous allons donc avoir un exemple ici, mais il s'agit d'une notation similaire à celle que vous voyez dans de nombreux langages.

Les indices commencent à zéro. Les éléments sont initialisés à une valeur nulle (ce n'est pas toujours le cas dans les autres langages). En C, par exemple, sans code dédié, un tableau n'est pas du tout initialisé.

Lors de la définition, les éléments du tableau sont initialisés avec la valeur nulle correspondant au type. S'il s'agit d'un entier, la valeur nulle est simplement zéro. S'il s'agit de chaînes de caractères, la valeur nulle est une chaîne vide.

Dans cet exemple, nous montrons comment déclarer un tableau.

var x [5]int
 
x[0] = 2
 
fmt.Printf(x[1])

La notation [5]int déclare un tableau de cinq entiers. Il serait initialisé à 0 par défaut. Sur la ligne suivante, on affecte la valeur 2 à l'élément d'indice 0 du tableau (le premier élément). L'élément x[0] vaut à présent : 2.

Sur la dernière ligne, l'appel de la fonction Printf permet d'afficher l'élément d'indice 1 du tableau (x[1] est le deuxième élément du tableau x). Cet élément n'a pas été explicitement affecté, il a donc encore la valeur par défaut 0.

Donc, l'appel de Printf( x[1] ) affichera 0.

Un tableau littéral est un ensemble prédéfini de valeurs qui constituent un tableau. Vous pouvez donc l'utiliser pour initialiser les tableaux si vous le souhaitez.

var x  = [5]int {1, 2, 3, 4, 5}
 
fmt.Printf( x )

Dans l'exemple ci-dessus, il s'agit donc d'un tableau de cinq entiers dont les valeurs sont définies littéralement entre accolades. C'est une façon d'initialiser le tableau à un ensemble de valeurs : C'est ce qu'on appelle un tableau littéral, et nous affectons à x ce tableau.

Le nombre d'éléments définis littéralement doit correspondre à la taille du tableau littéral.

Vous pouvez utiliser le mot clé … pour indiquer que la taille du tableau doit être déduite à partir du nombre d'éléments à l'intérieur du tableau littéral

var tbl = [...]int {10, 20, 30, 40, 50, 60, 70, 80, 90}
 
x := [...]int {1, 2, 3, 4}

Ainsi, dans l'exemple ci-dessus nous ne précisons pas explicitement la taille du tableau : comme il contient quatre éléments, il est clair que vous voulez que x soit de taille quatre.

L'opération la plus courante sur les tableaux consiste à itérer. Vous parcourez chaque élément du tableau et vous faites quelque chose avec l'élément du tableau.

Pour cela on utilise une boucle for, un exemple ci-dessous :

x := [3]int {1, 2, 3}
 
for i, v range x {
   fmt.Printf("index %d, value %d", i, v)
}

x est un tableau de 3 éléments de type entiers : un, deux et trois. Nous voulons maintenant parcourir ce tableau. Pour par exemple afficher chaque élément du tableau.

Nous utilisons une boucle for. Maintenant, Notez la présence du mot clé à *range**. À droite du mot clé range se trouve le nom du tableau que nous voulons parcourir.

À gauche, nous utilisons deux variables i, v. i contient l'indice de l'élément du tableau que nous examinons dans cette passe particulière (itération), et v contient la valeur de l'élément.

Le bloc de la boucle contient une seule instruction : l'appel de la fonction Printf pour afficher un message contenant les valeurs de i et v. Ainsi, à chaque passage de la boucle, i et v sont liés à des valeurs différentes. i est l'indice de l'élément que nous examinons, et v est sa valeur associée.

Avec ce tableau x, au premier passage de la boucle i vaudra 0, à la prochaine passe i vaudra 1, à la prochaine passe i vaudra 2. L'indice augmente à chaque fois.

v sera la i+1 valeur du tableau. Ainsi, lors du premier passage où i vaut 0, v sera égal à 1 car c'est la valeur du premier élément de ce tableau. L'élément 0 à la valeur 1. Ensuite, au passage suivant, i vaudra 1 et v vaudra 2, car l'élément d'index 1 est le deuxième élément, et sa valeur est 2. Et ainsi de suite.

Tout ce que fait cette boucle est très simple, elle imprime simplement les valeurs des variables i et v ensemble, mais vous voyez ici le principe de l'itération.

Cela permet d'itérer dans le tableau. Ainsi, i et v sont liés à l' index et à la valeur de l'élément du tableau à chaque passage. Et à l' intérieur de la boucle, nous pouvons faire ce que nous voulons avec ces variables v et i.

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷